@tinycloud/replica 0.2.4-beta.1 → 0.2.4-beta.2

package/dist/sqlite.js

@@ -1,8 +1,8 @@
 // src/sqlite/store.ts
 import { randomBytes } from "crypto";
-import { constants as fsConstants } from "fs";
-import { chmod, link, mkdir, open, readFile, readdir, rm, rmdir, stat, unlink } from "fs/promises";
-import { join } from "path";
+import { closeSync, constants as fsConstants, fstatSync, lstatSync, openSync, readdirSync, readlinkSync } from "fs";
+import { chmod, link, lstat, mkdir, open, readFile, readdir, rm, rmdir, stat, unlink } from "fs/promises";
+import { dirname, join, resolve } from "path";
 
 // src/errors.ts
 var ReplicaErrorCode = {
@@ -199,6 +199,29 @@ async function loadSqlite() {
 
 // src/sqlite/store.ts
 var SCHEMA_VERSION = 1;
+var sqliteOpenQueue = Promise.resolve();
+async function acquireSqliteOpen() {
+  const previous = sqliteOpenQueue;
+  let release;
+  sqliteOpenQueue = new Promise((resolve2) => {
+    release = resolve2;
+  });
+  await previous;
+  return release;
+}
+async function captureNamedPath(path) {
+  const names = [];
+  for (let current = resolve(path); ; current = dirname(current)) {
+    names.push(current);
+    if (dirname(current) === current) break;
+  }
+  const identities = [];
+  for (const name of names.reverse()) {
+    const stats = await lstat(name, { bigint: true });
+    identities.push({ path: name, dev: stats.dev, ino: stats.ino });
+  }
+  return identities;
+}
 var DURABILITY = "sqlite-wal-synchronous-full+fsynced-blobs";
 var SCHEMA = `
 CREATE TABLE IF NOT EXISTS replica (
@@ -297,22 +320,37 @@ async function entriesOf(path) {
   }
 }
 var FAULTS = /* @__PURE__ */ Symbol("tinycloud.replica.faults");
+var pinnedDirectories = new FinalizationRegistry((fd) => {
+  try {
+    closeSync(fd);
+  } catch {
+  }
+});
 var SqliteReplicaStore = class _SqliteReplicaStore {
   dir;
   #db;
+  #pinnedDir;
+  #directoryFd;
   #holder = `${process.pid}-${randomBytes(6).toString("hex")}`;
   #now;
   #faults;
   #guard;
   /** Identity of the database file this store opened: a deleted-and-recreated replica is a different file. */
   #ino;
-  constructor(dir, db, ino, options) {
+  #dev;
+  #namedAncestors;
+  constructor(dir, db, identity, options, directoryFd, namedAncestors = []) {
     this.dir = dir;
+    this.#pinnedDir = directoryFd !== void 0 && process.platform === "linux" ? `/proc/self/fd/${directoryFd}` : dir;
+    this.#directoryFd = directoryFd;
+    if (directoryFd !== void 0) pinnedDirectories.register(this, directoryFd, this);
     this.#db = db;
-    this.#ino = ino;
+    this.#ino = identity.ino;
+    this.#dev = identity.dev;
     this.#now = options.now ?? Date.now;
     this.#faults = options[FAULTS] ?? {};
     this.#guard = options.guard ?? ((section) => section());
+    this.#namedAncestors = namedAncestors;
   }
   /**
    * Read-only status snapshot; does not create a replica, migrate, recover
@@ -325,9 +363,10 @@ var SqliteReplicaStore = class _SqliteReplicaStore {
     };
     checkAbort();
     const dbPath = join(dir, "replica.db");
-    let ino;
+    let identity;
     try {
-      ino = (await stat(dbPath)).ino;
+      identity = await lstat(dbPath);
+      if (!identity.isFile()) return null;
     } catch (error) {
       if (errnoOf(error) === "ENOENT") return null;
       throw storageError(error, "Inspecting the replica");
@@ -340,14 +379,14 @@ var SqliteReplicaStore = class _SqliteReplicaStore {
       db = opener(dbPath, { readonly: true });
       db.exec("PRAGMA busy_timeout = 0");
       checkAbort();
-      const store = new _SqliteReplicaStore(dir, db, ino, { create: false, ...options.now ? { now: options.now } : {} });
+      const store = new _SqliteReplicaStore(dir, db, identity, { create: false, ...options.now ? { now: options.now } : {} });
       for (let attempt = 0; attempt < 2; attempt++) {
         const before = db.get("PRAGMA data_version").data_version;
         const state = await store.open();
         checkAbort();
         if (state === null) return null;
         const status = await store.status();
-        await new Promise((resolve) => setImmediate(resolve));
+        await new Promise((resolve2) => setImmediate(resolve2));
         checkAbort();
         const after = db.get("PRAGMA data_version").data_version;
         if (before === after) return { state, status };
@@ -367,65 +406,145 @@ var SqliteReplicaStore = class _SqliteReplicaStore {
    * REPLICA_NOT_FOUND and nothing is written to disk.
    */
   static async open(dir, options) {
-    const dbPath = join(dir, "replica.db");
+    const namedDbPath = join(dir, "replica.db");
     if (!options.create) {
-      const exists = await stat(dbPath).then(
-        () => true,
+      const exists = await lstat(namedDbPath).then(
+        (stats) => stats.isFile(),
         () => false
       );
-      if (!exists) throw new ReplicaError(ReplicaErrorCode.NOT_FOUND, `No replica at ${dir}.`);
+      if (!exists) throw new ReplicaError(ReplicaErrorCode.NOT_FOUND, `No regular replica database at ${dir}.`);
     }
     const opener = options.sqlite ?? await loadSqlite();
+    const releaseOpen = await acquireSqliteOpen();
     let store;
+    let directoryFd;
     try {
-      if (options.create) {
-        await mkdir(join(dir, "blobs", ".tmp"), { recursive: true, mode: 448 });
-        await Promise.all([chmod(dir, 448), chmod(join(dir, "blobs"), 448), chmod(join(dir, "blobs", ".tmp"), 448)]);
-        const handle = await open(dbPath, fsConstants.O_CREAT | fsConstants.O_RDWR, 384);
-        await handle.close();
-        await chmod(dbPath, 384);
+      if (options.create) await mkdir(dir, { recursive: true, mode: 448 });
+      if (process.platform === "linux") {
+        directoryFd = openSync(dir, fsConstants.O_RDONLY | fsConstants.O_DIRECTORY | fsConstants.O_NOFOLLOW);
       }
-      const ino = (await stat(dbPath)).ino;
-      const db = opener(dbPath);
-      db.exec("PRAGMA busy_timeout = 5000");
-      db.exec("PRAGMA journal_mode = WAL");
-      db.exec("PRAGMA synchronous = FULL");
-      db.exec("PRAGMA secure_delete = ON");
-      db.exec("PRAGMA foreign_keys = ON");
-      const version = db.get("PRAGMA user_version")?.user_version ?? 0;
-      if (version > SCHEMA_VERSION) {
-        db.close();
-        throw new ReplicaError(
-          ReplicaErrorCode.STORAGE_ERROR,
-          `The replica at ${dir} was written by a newer tc (schema ${version}); upgrade tc to read it.`
-        );
+      const opened = directoryFd === void 0 ? lstatSync(dir, { bigint: true }) : fstatSync(directoryFd, { bigint: true });
+      if (!opened.isDirectory() || opened.isSymbolicLink() || options.expectedDirectory && (opened.dev !== BigInt(options.expectedDirectory.dev) || opened.ino !== BigInt(options.expectedDirectory.ino))) {
+        throw new Error("The replica directory changed before SQLite opened it.");
+      }
+      const namedAncestors = process.platform === "linux" ? [] : await captureNamedPath(dir);
+      if (namedAncestors.length && (namedAncestors[namedAncestors.length - 1].dev !== opened.dev || namedAncestors[namedAncestors.length - 1].ino !== opened.ino)) {
+        throw new Error("The replica directory changed while checking its ancestry.");
       }
-      if (version < SCHEMA_VERSION) {
-        db.exec("BEGIN IMMEDIATE");
-        db.exec(SCHEMA);
-        db.exec(`PRAGMA user_version = ${SCHEMA_VERSION}`);
-        db.exec("COMMIT");
+      const pinnedDir = directoryFd === void 0 ? dir : `/proc/self/fd/${directoryFd}`;
+      const dbPath = join(pinnedDir, "replica.db");
+      if (options.create) {
+        await mkdir(join(pinnedDir, "blobs", ".tmp"), { recursive: true, mode: 448 });
+        await Promise.all([chmod(pinnedDir, 448), chmod(join(pinnedDir, "blobs"), 448), chmod(join(pinnedDir, "blobs", ".tmp"), 448)]);
+        const handle = await open(dbPath, fsConstants.O_CREAT | fsConstants.O_EXCL | fsConstants.O_RDWR | fsConstants.O_NOFOLLOW, 384).catch((error) => {
+          if (errnoOf(error) === "EEXIST") return null;
+          throw error;
+        });
+        if (handle) {
+          try {
+            await handle.chmod(384);
+          } finally {
+            await handle.close();
+          }
+        }
+      }
+      const leaf = await open(dbPath, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
+      let db;
+      try {
+        const identity = await leaf.stat();
+        const named = await lstat(dbPath);
+        if (!identity.isFile() || !named.isFile() || named.dev !== identity.dev || named.ino !== identity.ino) {
+          throw new Error("The replica database changed before SQLite opened it.");
+        }
+        const previousFds = process.platform === "linux" && !options.sqlite ? new Map(readdirSync("/proc/self/fd").map((fd) => {
+          try {
+            return [fd, readlinkSync(`/proc/self/fd/${fd}`)];
+          } catch {
+            return [fd, ""];
+          }
+        })) : null;
+        db = opener(dbPath);
+        const afterOpen = lstatSync(dbPath);
+        if (!afterOpen.isFile() || afterOpen.dev !== identity.dev || afterOpen.ino !== identity.ino) {
+          throw new Error("The replica database changed while SQLite opened it.");
+        }
+        if (previousFds) db.get("SELECT count(*) FROM sqlite_master");
+        if (previousFds) {
+          const databases = readdirSync("/proc/self/fd").filter((fd) => {
+            try {
+              const target = readlinkSync(`/proc/self/fd/${fd}`);
+              return target.endsWith("/replica.db") && previousFds.get(fd) !== target;
+            } catch {
+              return false;
+            }
+          });
+          if (databases.length === 0 || databases.some((fd) => {
+            try {
+              const actual = fstatSync(Number(fd));
+              return actual.dev !== identity.dev || actual.ino !== identity.ino;
+            } catch {
+              return true;
+            }
+          })) {
+            throw new Error("SQLite opened a different replica database.");
+          }
+        }
+        const after = lstatSync(dbPath);
+        if (!after.isFile() || after.dev !== identity.dev || after.ino !== identity.ino) {
+          throw new Error("The replica database changed while SQLite opened it.");
+        }
+        db.exec("PRAGMA busy_timeout = 5000");
+        db.exec("PRAGMA journal_mode = WAL");
+        db.exec("PRAGMA synchronous = FULL");
+        db.exec("PRAGMA secure_delete = ON");
+        db.exec("PRAGMA foreign_keys = ON");
+        const version = db.get("PRAGMA user_version")?.user_version ?? 0;
+        if (version > SCHEMA_VERSION) {
+          throw new ReplicaError(
+            ReplicaErrorCode.STORAGE_ERROR,
+            `The replica at ${dir} was written by a newer tc (schema ${version}); upgrade tc to read it.`
+          );
+        }
+        if (version < SCHEMA_VERSION) {
+          db.exec("BEGIN IMMEDIATE");
+          db.exec(SCHEMA);
+          db.exec(`PRAGMA user_version = ${SCHEMA_VERSION}`);
+          db.exec("COMMIT");
+        }
+        store = new _SqliteReplicaStore(dir, db, identity, options, directoryFd, namedAncestors);
+        db = void 0;
+      } finally {
+        try {
+          db?.close();
+        } finally {
+          await leaf.close();
+        }
       }
-      store = new _SqliteReplicaStore(dir, db, ino, options);
     } catch (error) {
+      if (store) await store.close().catch(() => void 0);
+      else if (directoryFd !== void 0) closeSync(directoryFd);
       throw storageError(error, `Opening the replica at ${dir}`);
+    } finally {
+      releaseOpen();
     }
-    const row = store.#row();
-    if (row?.revoked_detail != null && (row.purge_pending === 1 || await store.#holdsContentFiles().catch(() => true))) {
-      await store.#finishRevocationPurge().catch(() => void 0);
+    try {
+      const row = store.#row();
+      if (row?.revoked_detail != null && (row.purge_pending === 1 || await store.#holdsContentFiles().catch(() => true))) {
+        await store.#finishRevocationPurge().catch(() => void 0);
+      }
+      return store;
+    } catch (error) {
+      await store.close().catch(() => void 0);
+      throw error;
     }
-    return store;
   }
   #row() {
     return this.#db.get("SELECT * FROM replica WHERE id = 1");
   }
   /** Refuse to touch the filesystem for a replica that was deleted (or replaced) under us. */
   async #assertPresent() {
-    const ino = await stat(join(this.dir, "replica.db")).then(
-      (stats) => stats.ino,
-      () => void 0
-    );
-    if (ino !== this.#ino) {
+    const identity = await lstat(join(this.#pinnedDir, "replica.db")).catch(() => null);
+    if (!identity?.isFile() || identity.dev !== this.#dev || identity.ino !== this.#ino) {
       throw new ReplicaError(
         ReplicaErrorCode.NOT_FOUND,
         `The replica at ${this.dir} was deleted while this command ran (its profile was deleted or the replica purged); nothing more was written.`
@@ -655,7 +774,7 @@ var SqliteReplicaStore = class _SqliteReplicaStore {
     return held;
   }
   #blobPath(hash) {
-    return join(this.dir, "blobs", hash.slice(0, 2), hash);
+    return join(this.#pinnedDir, "blobs", hash.slice(0, 2), hash);
   }
   /**
    * Make every blob durable before any row references it: write to a fresh
@@ -672,11 +791,11 @@ var SqliteReplicaStore = class _SqliteReplicaStore {
         () => false
       );
       if (exists) continue;
-      const shard = join(this.dir, "blobs", hash.slice(0, 2));
+      const shard = join(this.#pinnedDir, "blobs", hash.slice(0, 2));
       await mkdir(shard, { mode: 448 }).catch((error) => {
         if (errnoOf(error) !== "EEXIST") throw error;
       });
-      const temp = join(this.dir, "blobs", ".tmp", `${hash}.${randomBytes(6).toString("hex")}`);
+      const temp = join(this.#pinnedDir, "blobs", ".tmp", `${hash}.${randomBytes(6).toString("hex")}`);
       const handle = await open(temp, fsConstants.O_CREAT | fsConstants.O_EXCL | fsConstants.O_WRONLY, 384);
       try {
         await handle.writeFile(bytes);
@@ -692,7 +811,7 @@ var SqliteReplicaStore = class _SqliteReplicaStore {
         await unlink(temp);
       }
       dirs.add(shard);
-      dirs.add(join(this.dir, "blobs"));
+      dirs.add(join(this.#pinnedDir, "blobs"));
     }
     for (const dir of dirs) {
       const handle = await open(dir, fsConstants.O_RDONLY);
@@ -800,7 +919,7 @@ var SqliteReplicaStore = class _SqliteReplicaStore {
   /** Unlink every blob not in `keep`, and every temp file. Only a missing directory counts as empty. */
   async #unlinkBlobs(keep) {
     let removed = 0;
-    const root = join(this.dir, "blobs");
+    const root = join(this.#pinnedDir, "blobs");
     for (const shard of await entriesOf(root)) {
       const shardPath = join(root, shard);
       if (shard === ".tmp") {
@@ -825,7 +944,7 @@ var SqliteReplicaStore = class _SqliteReplicaStore {
   }
   /** Whether any content file (a blob or a temp file) is on disk. */
   async #holdsContentFiles() {
-    const root = join(this.dir, "blobs");
+    const root = join(this.#pinnedDir, "blobs");
     for (const shard of await entriesOf(root)) {
       if ((await entriesOf(join(root, shard))).length > 0) return true;
     }
@@ -891,8 +1010,93 @@ var SqliteReplicaStore = class _SqliteReplicaStore {
       }
       try {
         this.#checkLease(t, { allowRevoked: true });
+        const expected = this.#directoryFd === void 0 ? this.#namedAncestors.at(-1) : fstatSync(this.#directoryFd, { bigint: true });
+        if (!expected) {
+          throw new ReplicaError(ReplicaErrorCode.RUNTIME_UNSUPPORTED, "Replica removal requires an opened or identity-checked directory.");
+        }
+        const assertDirectory = async () => {
+          const current = await lstat(this.dir, { bigint: true });
+          if (!current.isDirectory() || current.dev !== expected.dev || current.ino !== expected.ino) {
+            throw new ReplicaError(ReplicaErrorCode.NOT_FOUND, "The replica directory changed during removal.");
+          }
+          return current;
+        };
+        const pinned = await assertDirectory();
         await this.#assertPresent();
-        await rm(this.dir, { recursive: true, force: true });
+        if (process.platform === "linux") {
+          for (const entry of await readdir(this.#pinnedDir)) {
+            await rm(join(this.#pinnedDir, entry), { recursive: true, force: true });
+          }
+          await assertDirectory();
+          await rmdir(this.dir);
+        } else {
+          const ancestors = this.#namedAncestors;
+          const checkAncestors = async () => {
+            for (const expected2 of ancestors) {
+              const current = await lstat(expected2.path, { bigint: true });
+              if (current.dev !== expected2.dev || current.ino !== expected2.ino) {
+                throw new ReplicaError(ReplicaErrorCode.NOT_FOUND, "The replica ancestry changed during removal.");
+              }
+            }
+          };
+          const directories = /* @__PURE__ */ new Map([[this.dir, pinned]]);
+          const files = /* @__PURE__ */ new Map();
+          const check = async (path, expected2, directory) => {
+            if (path !== this.dir) {
+              const parent = dirname(path);
+              await check(parent, directories.get(parent), true);
+            }
+            await checkAncestors();
+            const current = await lstat(path, { bigint: true });
+            if ((directory ? !current.isDirectory() : !current.isFile()) || current.dev !== expected2.dev || current.ino !== expected2.ino) {
+              throw new ReplicaError(ReplicaErrorCode.NOT_FOUND, "The replica layout changed during removal.");
+            }
+          };
+          const record = async (path, directory) => {
+            const parent = dirname(path);
+            await check(parent, directories.get(parent), true);
+            const current = await lstat(path, { bigint: true });
+            if (!(directory ? current.isDirectory() : current.isFile())) {
+              throw new ReplicaError(ReplicaErrorCode.STORAGE_ERROR, "Unexpected replica layout during removal.");
+            }
+            (directory ? directories : files).set(path, current);
+          };
+          const blobs = join(this.dir, "blobs");
+          for (const name of await readdir(this.dir)) {
+            if (name === "blobs") await record(blobs, true);
+            else if (["replica.db", "replica.db-wal", "replica.db-shm"].includes(name)) await record(join(this.dir, name), false);
+            else throw new ReplicaError(ReplicaErrorCode.STORAGE_ERROR, "Unexpected replica layout during removal.");
+          }
+          if (directories.has(blobs)) {
+            await check(blobs, directories.get(blobs), true);
+            for (const shard of await readdir(blobs)) {
+              if (shard !== ".tmp" && !/^[0-9a-f]{2}$/.test(shard)) {
+                throw new ReplicaError(ReplicaErrorCode.STORAGE_ERROR, "Unexpected replica blob shard during removal.");
+              }
+              const shardPath = join(blobs, shard);
+              await record(shardPath, true);
+              await check(shardPath, directories.get(shardPath), true);
+              for (const name of await readdir(shardPath)) {
+                if (shard === ".tmp" ? !/^[0-9a-f]{64}\.[0-9a-f]{12}$/.test(name) : !isHash(name) || !name.startsWith(shard)) {
+                  throw new ReplicaError(ReplicaErrorCode.STORAGE_ERROR, "Unexpected replica blob file during removal.");
+                }
+                await record(join(shardPath, name), false);
+              }
+            }
+          }
+          for (const [path, identity] of files) {
+            await check(path, identity, false);
+            await unlink(path);
+          }
+          for (const [path, identity] of [...directories].reverse()) {
+            if (path === this.dir) continue;
+            await check(path, identity, true);
+            await rmdir(path);
+          }
+          await assertDirectory();
+          await checkAncestors();
+          await rmdir(this.dir);
+        }
       } catch (error) {
         throw storageError(error, "Removing the replica");
       } finally {
@@ -1058,7 +1262,14 @@ var SqliteReplicaStore = class _SqliteReplicaStore {
     };
   }
   async close() {
-    this.#db.close();
+    const fd = this.#directoryFd;
+    this.#directoryFd = void 0;
+    if (fd !== void 0) pinnedDirectories.unregister(this);
+    try {
+      this.#db.close();
+    } finally {
+      if (fd !== void 0) closeSync(fd);
+    }
   }
 };
 export {