@ai-ecoverse/slicc-kernel 1.22.0 → 1.22.1

package/README.md

@@ -118,7 +118,7 @@ const { status, stdout } = await kernel.run(['bash', '-c', 'echo hi'], { cwd: '/
 kernel.terminate();
 ```
 
-`createNodeKernel({ root, modules, env, network, worker, processMounts })` takes the options of `createKernel` except `metadata`. `root` is an in-memory directory by default (`memoryRoot()` makes another), and POSIX metadata stays in memory. Processes and threads run on `worker_threads`. The kernel has `run`, `openTerminal` and `terminate` as above, plus `root`, `writeFile(path, data)` (creating the parent directories) and `readFile(path)` to put files in place and read results. `nodeTransport()` is `fetchTransport()` with Node's `fetch`, which no CORS binds (`crossOrigin: 'any'`). `connect()` and `attachKernel` work as in the browser: the port is a `worker_threads` `MessagePort`, which a worker thread can attach with, and `terminate()` ends every attached client.
+`createNodeKernel({ root, modules, env, network, worker, processMounts, fstabRetries })` takes the options of `createKernel` except `metadata`, and `fstabRetries`, the delays in ms between tries of a failing `/etc/fstab` line (default `[1000, 4000, 16000]`). `root` is an in-memory directory by default (`memoryRoot()` makes another), and POSIX metadata stays in memory. Processes and threads run on `worker_threads`. The kernel has `run`, `openTerminal` and `terminate` as above, plus `root`, `writeFile(path, data)` (creating the parent directories) and `readFile(path)` to put files in place and read results. `nodeTransport()` is `fetchTransport()` with Node's `fetch`, which no CORS binds (`crossOrigin: 'any'`). `connect()` and `attachKernel` work as in the browser: the port is a `worker_threads` `MessagePort`, which a worker thread can attach with, and `terminate()` ends every attached client.
 
 ## Commands
 
@@ -230,6 +230,7 @@ project        /mnt/project  hostfs  ro           0 0
 
 - **Boot never waits for it:** the lines are mounted in the background once the kernel has started, all at once, so a slow source holds up nothing.
 - **Retries:** a line that fails is tried again after 1, 4 and 16 seconds (a driver package installed meanwhile, a mount point created later), except when it cannot succeed (`EINVAL`, `EBUSY`, `EPERM`, `EACCES`). `terminate()` stops the retries.
+- **Failures are listed:** until it mounts, a line is in `kernel.mounts()` with state `pending`, and once it gives up with state `failed`, each with the last `error`. `/proc/mounts` and `mount` show the state in its options, as `none /mnt/bad nosuchfs rw,failed 0 0`. Unmounting a failed line's target takes it off the list. A line whose target another line mounted is not listed.
 - **No user involvement:** an `fsa` line names a drive by its id: it comes up with the folder it had while its permission holds, and otherwise with no medium, asking the page for the folder through `onMountPending`, as any `fsa` mount does. With `media: false` the drive finds its folder only within the same kernel. With the default `media`, an `fsa` line reads its folder handle back from IndexedDB at boot, which crashes Chrome in an Incognito or other off-the-record profile ([#95](https://github.com/ai-ecoverse/slicc-kernel/issues/95)); a page cannot reliably tell it runs in one, so an embedder that cannot rule it out passes `media: false`, which keeps `fsa` lines in `/etc/fstab` safe. A `hostfs` line waits only for its first connection, and comes up with no medium if the proxy is not there yet.
 
 ### Removable media: `fsa`

package/dist/kernel-worker.js

@@ -4128,6 +4128,7 @@ var MountTable = class {
   mounts = /* @__PURE__ */ new Map();
   devices = 0;
   pending = /* @__PURE__ */ new Set();
+  notes = /* @__PURE__ */ new Map();
   deps;
   constructor(deps) {
     this.deps = deps;
@@ -4136,7 +4137,7 @@ var MountTable = class {
     return this.mounts.get(target);
   }
   list() {
-    return [...this.mounts.values()].map(
+    const mounted = [...this.mounts.values()].map(
       ({ type, source, target, options, state, error, present }) => ({
         type,
         source,
@@ -4146,6 +4147,19 @@ var MountTable = class {
         ...error ? { error } : {}
       })
     );
+    const noted = [...this.notes.values()].filter((note) => !this.mounts.has(note.target));
+    return [...mounted, ...noted.map((note) => ({ ...note, options: { ...note.options } }))];
+  }
+  note(spec, state, error) {
+    const target = normalizePath(spec.target);
+    this.notes.set(target, {
+      type: spec.type,
+      source: spec.source,
+      target,
+      options: { ...spec.options },
+      state,
+      ...error ? { error } : {}
+    });
   }
   locate(path) {
     let best;
@@ -4222,13 +4236,19 @@ var MountTable = class {
     };
     mounted = mount;
     this.mounts.set(target, mount);
+    this.notes.delete(target);
     return this.list().find((m) => m.target === target);
   }
+  unnote(target) {
+    this.notes.delete(normalizePath(target));
+  }
   umount(target, detach = false) {
     const at = normalizePath(target);
     const mount = this.mounts.get(at);
+    if (!mount && this.notes.delete(at)) return;
     if (!mount) throw errnoError("EINVAL", `${at} is not mounted`);
     if (!detach && this.deps.busy(at)) throw errnoError("EBUSY", `${at} has open files`);
+    this.notes.delete(at);
     this.mounts.delete(at);
     mount.conn.close();
     mount.dispose();
@@ -7717,28 +7737,34 @@ function wait(ms, signal) {
   });
 }
 async function mountFstab(lines, mount, signal, retries = FSTAB_RETRIES, discard = () => {
+}, settled = () => {
 }) {
   return Promise.all(
-    lines.map(async ({ line, spec, invalid }) => {
-      let failed = invalid;
-      for (let attempt = 0; !invalid && attempt <= retries.length && !signal.aborted; attempt++) {
-        try {
-          const entry = await mount(spec);
-          if (!signal.aborted) return { line, target: spec.target, entry };
-          discard(entry);
-          failed = Object.assign(new Error("the kernel stopped"), { code: "ECANCELED" });
-          break;
-        } catch (err) {
-          failed = err;
-          if (FINAL.has(codeOf3(err)) || attempt === retries.length) break;
-          await wait(retries[attempt], signal);
-        }
-      }
-      const code = codeOf3(failed);
-      return { line, target: spec.target, code, error: String(failed?.message ?? code) };
+    lines.map(async (each) => {
+      const result = await mountLine(each, mount, signal, retries, discard);
+      settled(each, result);
+      return result;
     })
   );
 }
+async function mountLine({ line, spec, invalid }, mount, signal, retries, discard) {
+  let failed = invalid;
+  for (let attempt = 0; !invalid && attempt <= retries.length && !signal.aborted; attempt++) {
+    try {
+      const entry = await mount(spec);
+      if (!signal.aborted) return { line, target: spec.target, entry };
+      discard(entry);
+      failed = Object.assign(new Error("the kernel stopped"), { code: "ECANCELED" });
+      break;
+    } catch (err) {
+      failed = err;
+      if (FINAL.has(codeOf3(err)) || attempt === retries.length) break;
+      await wait(retries[attempt], signal);
+    }
+  }
+  const code = codeOf3(failed);
+  return { line, target: spec.target, code, error: String(failed?.message ?? code) };
+}
 
 // src/mount/hostfs.ts
 var HOSTFS_IO = 16 * 1024 * 1024;
@@ -8541,6 +8567,7 @@ var Launcher = class {
   onMountPending;
   removable = /* @__PURE__ */ new Map();
   hostfs;
+  fstabRetries;
   inserted = /* @__PURE__ */ new Map();
   openFiles = /* @__PURE__ */ new Set();
   held = /* @__PURE__ */ new Set();
@@ -8562,6 +8589,7 @@ var Launcher = class {
     this.media = options.media ?? memoryMedia();
     this.onMountPending = options.onMountPending;
     this.hostfs = options;
+    this.fstabRetries = options.fstabRetries ?? FSTAB_RETRIES;
     this.processMounts = options.processMounts ?? true;
     this.pnpmHome = options.env?.PNPM_HOME ?? PNPM_HOME;
     this.modulesDir = options.modules ?? "/node_modules";
@@ -8995,12 +9023,22 @@ var Launcher = class {
   }
   async mountFstab() {
     const text = await this.base.readFile(FSTAB_PATH).catch(() => "");
+    const lines = parseFstab(text);
+    for (const { spec } of lines) this.mounts.note(spec, "pending");
     return mountFstab(
-      parseFstab(text),
-      (spec) => this.mount(spec),
+      lines,
+      (spec) => this.mount(spec).catch((err) => {
+        this.mounts.note(spec, "pending", err?.message ?? String(err));
+        throw err;
+      }),
       this.booting.signal,
-      FSTAB_RETRIES,
-      (entry) => this.umount(entry.target, true)
+      this.fstabRetries,
+      (entry) => this.umount(entry.target, true),
+      ({ spec }, result) => {
+        if (!result.code || result.code === "ECANCELED" || this.booting.signal.aborted) {
+          this.mounts.unnote(spec.target);
+        } else this.mounts.note(spec, "failed", result.error);
+      }
     );
   }
   environment(cwd, extra) {