@optimystic/db-p2p-storage-fs 1.14.0 → 1.16.0

package/dist/src/file-write-log.d.ts

@@ -0,0 +1,361 @@
+import { type CommittedBatch, type SetTimer, type SinkCommitOptions, type StoreIdentity } from '@optimystic/db-p2p';
+export declare const WRITE_LOG_FILENAME = "write-ahead.log";
+/**
+ * The log a checkpoint has sealed and is syncing the tree under. Present on disk only between a
+ * checkpoint's seal and its truncate; an open replays it ahead of {@link WRITE_LOG_FILENAME}.
+ */
+export declare const SEALED_WRITE_LOG_FILENAME = "write-ahead.log.sealed";
+/** {@link FileWriteLogOptions.checkpointBytes}'s default: 16 MiB. */
+export declare const DEFAULT_CHECKPOINT_BYTES: number;
+/** {@link FileWriteLogOptions.checkpointIdleMs}'s default. */
+export declare const DEFAULT_CHECKPOINT_IDLE_MS = 5000;
+/**
+ * The log's fixed header: the magic bytes `OPTIMYSTIC-WAL`, then one format-version byte. A file
+ * that does not start with exactly this is not a log this build wrote, and replay applies nothing
+ * from it.
+ */
+export declare const WRITE_LOG_FORMAT_VERSION = 1;
+export declare const WRITE_LOG_HEADER: Uint8Array;
+/**
+ * One write of a batch. `path` is relative to the store's directory, with forward slashes
+ * whatever the platform, so a log written on one platform replays on another.
+ */
+export type WriteLogEntry = {
+    readonly kind: 'put';
+    readonly path: string;
+    readonly value: Uint8Array;
+} | {
+    readonly kind: 'delete';
+    readonly path: string;
+};
+/**
+ * One record: `[u32 payload length][u32 CRC-32 of the payload][payload]`, little-endian, where the
+ * payload is the batch's entries in order, each `[u8 kind][u16 path length][path, UTF-8][u32 value
+ * length][value]`. A delete carries a zero-length value.
+ */
+export declare function encodeWriteLogRecord(entries: readonly WriteLogEntry[]): Uint8Array;
+/** Why a strict read of the log stopped before the end of the file. */
+export type WriteLogStop = 'bad-header' | 'torn-record' | 'crc-mismatch' | 'bad-entry';
+export interface DecodedWriteLog {
+    /** Every batch read, in log order. */
+    readonly batches: readonly (readonly WriteLogEntry[])[];
+    /** The byte offset reading stopped at: the file's length when every byte parsed. */
+    readonly stoppedAt: number;
+    /** Set when reading stopped short; the batches before the offending record are in `batches`. */
+    readonly stoppedBy?: WriteLogStop;
+}
+/**
+ * Read a log strictly: a header that is not ours, a record whose length runs past the end of the
+ * file, a CRC that does not match, or an entry that does not parse stops the read before that
+ * record. What precedes it is returned in order.
+ */
+export declare function decodeWriteLog(bytes: Uint8Array): DecodedWriteLog;
+/** The file's bytes, or `undefined` when there is no such file. Any other error propagates. */
+export declare function readFileIfExists(filePath: string): Promise<Uint8Array | undefined>;
+/**
+ * Best-effort fsync of a directory, so an entry added to, removed from or renamed within it
+ * survives power loss. POSIX needs this; platforms that reject opening a directory for fsync
+ * throw, and the throw is ignored rather than failing the write.
+ *
+ * Skipped outright on win32: there `fs.open(dir, 'r')` SUCCEEDS and only the following
+ * `handle.sync()` fails with EPERM, so the open/close pair was guaranteed wasted work. Durability
+ * is unchanged on win32 (the sync never succeeded there).
+ *
+ * NOTE: every error is swallowed, an I/O error included, and a checkpoint discards its sealed log
+ * on the strength of these syncs. A directory sync that fails with EIO therefore lets the log go
+ * while a directory entry it covered may not be durable. If that is ever seen, swallow only the
+ * codes a filesystem uses to refuse a directory sync (EINVAL, ENOTSUP, EISDIR, EPERM, EBADF) and
+ * ENOENT, and let the rest fail the checkpoint.
+ */
+export declare function fsyncDir(dir: string): Promise<void>;
+/** fsync a file in place; a file that no longer exists is skipped. Opened `r+`: Windows refuses to flush a read-only handle. */
+export declare function fsyncFile(filePath: string): Promise<void>;
+/**
+ * The identity every store over `basePath` reports (`RawStoreDriver.storeIdentity`): `file:` and
+ * the directory resolved once, here. `path.resolve` is cwd-dependent, and resolving at construction
+ * is the correct reading — two stores built from the same RELATIVE path under different cwds
+ * genuinely address different directories and must not compare equal. An empty basePath resolves
+ * to the cwd; nothing special-cases it. (A whitespace-only basePath is NOT the cwd — `path.resolve`
+ * is pure string work, so `' '` names a child directory called `' '`.)
+ *
+ * Lowercased on win32 because Windows paths are case-insensitive: `C:\Foo` and `C:\foo` are one
+ * directory and must produce one identity.
+ *
+ * NOTE: aliases of one directory that this does NOT collapse, and so read as two identities:
+ * symlinks, junctions, UNC-versus-mapped-drive spellings, and case-differing spellings on a
+ * case-INSENSITIVE non-Windows volume (the default on macOS) — platform is the only signal
+ * available synchronously, and case-folding every darwin path would be wrong on a case-sensitive
+ * volume. `fs.realpath` resolves all of these, but it is async (a store's constructor is not) and
+ * requires the directory to already exist. Revisit if an alias ever bites. All of these fail in
+ * the SAFE direction for the read cache: a missed alias reports two identities for one directory,
+ * so an identity-keyed consumer declines to merge and gets today's behavior. For the write-ahead
+ * log they fail less safely: two stores over two spellings of one directory open two logs, and
+ * the second is refused by the lock.
+ * NOTE: the win32 fold is the one branch that can err in the UNSAFE direction — Windows 10+
+ * supports per-directory case sensitivity (`fsutil file setCaseSensitiveInfo`), and on such a
+ * directory `X:\p\Foo` and `X:\p\foo` are two directories folded onto ONE identity. The merging
+ * consumers — `withReadCache` (one read cache per identity) and the log registry below (one log
+ * per identity) — would then read and write two directories through one cache and one log. Not
+ * addressable synchronously either (the flag is a per-directory filesystem query). Revisit if
+ * Optimystic ever targets a case-sensitive-enabled Windows directory; until then the fold is
+ * right for every ordinary Windows volume.
+ */
+export declare function fileStoreIdentity(basePath: string): StoreIdentity;
+/** Paths the tree has been written to since the log was last checkpointed; the checkpoint's work list. */
+export interface DirtyPaths {
+    /** Absolute paths of files written, less those deleted since. */
+    readonly files: Set<string>;
+    /** Absolute paths of directories whose entries changed: a file written or deleted in them, or a directory created in them. */
+    readonly directories: Set<string>;
+}
+/** When the log is checkpointed. Shared by every store over the directory; see {@link FileWriteLog.acquire}. */
+export interface FileWriteLogOptions {
+    /**
+     * Checkpoint once the log holds at least this many bytes of records, checked after each append.
+     * Default {@link DEFAULT_CHECKPOINT_BYTES}.
+     */
+    checkpointBytes?: number;
+    /**
+     * Checkpoint this long after the last append, so a store that stops writing does not keep its
+     * log until it closes. Re-armed by every append. Default {@link DEFAULT_CHECKPOINT_IDLE_MS}.
+     */
+    checkpointIdleMs?: number;
+    /** Arms the idle checkpoint; defaults to an unref'd `setTimeout`, so it never holds a process open. Injected by tests. */
+    setTimer?: SetTimer;
+}
+/** Throws a `RangeError` for a checkpoint setting out of range; a store's constructor calls it, so a bad setting fails there rather than at the first write. */
+export declare function assertFileWriteLogOptions(options: FileWriteLogOptions): void;
+/**
+ * The write-ahead log of one store directory: `<basePath>/write-ahead.log`, every batch of writes
+ * appended as one record, synced by the earliest deadline any batch was given, and applied to the
+ * readable file tree once it is durable.
+ *
+ * The write-ahead rule: a tree file only ever holds content whose log record is durable. So what
+ * survives a crash is the log's durable prefix plus whatever the tree already held, and {@link open}
+ * reconstructs it by replaying the log in order (puts and deletes are idempotent) before anything
+ * is served. A replay of a put over a newer tree file cannot happen: every tree write has a log
+ * record, and the log is replayed in order, so the last record for a path is the newest content
+ * the tree was ever given. A store written by a build before the log has no log file and opens
+ * with nothing to replay.
+ *
+ * A record reaches the operating system in its commit, so it survives a crash of this process from
+ * then on: the next open's replay applies it. What the sync adds is surviving a power cut, and a
+ * {@link commit} allowed to wait for that (`syncWithinMs` above 0) resolves without it, so that one
+ * sync, made by the earliest deadline, covers every record appended since the last. The rules are
+ * at {@link commit} and {@link syncUnsynced}.
+ *
+ * A {@link checkpoint} makes the tree as durable as the log and then discards the log, so the log
+ * never grows without bound: it runs when the log passes `checkpointBytes`, `checkpointIdleMs` after
+ * the last append, and on the last {@link release}. Its three steps are under {@link checkpointOnce}.
+ *
+ * One instance per directory per process, shared by reference count through {@link acquire}, so
+ * every store over one directory in one process — `FileRawStorage` and `FileKVStore` alike — shares
+ * one log, one lock and one checkpoint, rather than deadlocking on the lock or interleaving two
+ * writers into one file. Each keeps its own overlay above this, which is why a second store opened
+ * beside a first cannot see the first's unflushed writes.
+ */
+export declare class FileWriteLog {
+    readonly basePath: string;
+    readonly identity: StoreIdentity;
+    private readonly settings;
+    /** A previous log over this directory still releasing its handle and lock; opening waits for it. */
+    private readonly predecessorClosed;
+    private static readonly registry;
+    /** Logs whose last reference was released and whose handle and lock are still being let go of. */
+    private static readonly closing;
+    /**
+     * The shared log for the directory, counted once more. Synchronous, so two acquirers in one
+     * tick get one instance. Balance every call with one {@link release}.
+     *
+     * The checkpoint settings are the first acquirer's: a store opened over a directory whose log is
+     * already open shares that log's settings, and a setting it names that differs is logged and
+     * not applied.
+     */
+    static acquire(basePath: string, options?: FileWriteLogOptions): FileWriteLog;
+    readonly logPath: string;
+    readonly sealedPath: string;
+    /** What the tree has been given since the log was last sealed; see {@link DirtyPaths}. Swapped for an empty set by each seal. */
+    private dirty;
+    /** Bytes of records in the current log, the size threshold's measure. Zero means there is nothing to checkpoint. */
+    private appendedBytes;
+    private refs;
+    private opening;
+    private handle;
+    private lock;
+    /** Commits and seals run one at a time, in order, on this chain; it never rejects. */
+    private queue;
+    private fault;
+    private closed;
+    /** The checkpoint running now, if any, which also runs every one asked for while it ran. */
+    private checkpointRun;
+    /** A checkpoint was asked for while {@link checkpointRun} was running: run one more after it. */
+    private checkpointAgain;
+    private cancelIdleCheckpoint;
+    /**
+     * Records appended and not yet synced, in log order, each held with the entries the sync step
+     * writes to the tree and the `durable` it settles; with them the earliest deadline, the timer
+     * armed for it, and the `window-overrun` episode. Emptied by every sync step and by the latch.
+     * Bounded by the window: it holds what was committed since the last sync, and the earliest
+     * deadline among them forces one.
+     */
+    private readonly unsynced;
+    private constructor();
+    /** True once an open, an append, an apply or a checkpoint failed; every later commit then throws {@link StoreFailedError}. */
+    get failed(): boolean;
+    /**
+     * Take the lock, replay the log into the tree, truncate it and hold it open. Memoized: the first
+     * operation opens, every later one waits for that. A directory another live process holds throws
+     * {@link StoreLockedError} from every operation; an I/O failure latches the log failed and throws
+     * {@link StoreFailedError} from every operation. Either outcome is kept for the life of the
+     * instance, and the instance is shared by every store over the directory until each has released
+     * it: to retry after the holder has exited, close those stores and open a new one.
+     */
+    open(): Promise<void>;
+    /**
+     * Append the batch as one record and resolve with its `durable`, which settles once the record is
+     * synced and the batch written to the tree. Batches commit one at a time in the order they were
+     * submitted, and their `durable` settle in that order. `WriteGroupSink.commit`'s contract:
+     *
+     * - `syncWithinMs` 0 (**strict**): the sync step runs before this resolves, so the returned
+     *   `durable` is already settled and every earlier batch is durable too.
+     * - Otherwise (**relaxed**): the record is in the operating system and the batch waits in
+     *   {@link unsynced} with the deadline `syncWithinMs` after this was CALLED, not after the queue got
+     *   to it, so a commit that waited in line past its own deadline is treated as overdue. A timer
+     *   armed for the earliest deadline runs the sync step; a strict commit or a checkpoint meanwhile
+     *   runs it sooner, for every batch waiting.
+     * - **Backpressure:** a commit that finds the earliest unsynced deadline already passed runs the
+     *   sync step before it resolves, whatever its own window. When the disk falls behind, writers
+     *   wait for it instead of the window quietly growing.
+     *
+     * The deadlines, the timer and the backpressure test are the rules of `SyncDeadlines`, from
+     * `@optimystic/db-p2p`, which every store that defers its sync shares.
+     *
+     * The tree is written at the sync, not here, so a reader of the tree never sees a batch whose
+     * record a power cut could still take; the overlay above each store serves the batch until its
+     * `durable` resolves.
+     */
+    commit(entries: readonly WriteLogEntry[], { syncWithinMs }: SinkCommitOptions): Promise<CommittedBatch>;
+    /**
+     * Hasten: make every record appended before this call durable, and write its batch to the tree.
+     * Queued, so it covers exactly those records; with nothing unsynced it touches no disk.
+     * `WriteGroupSink.sync`'s contract.
+     */
+    sync(): Promise<void>;
+    /**
+     * Make the tree as durable as the log, then discard the log. One at a time: asked for while one
+     * runs, it runs once more after that one, and resolves when that has. Skipped when the log has
+     * failed, was never opened, or holds no record. A failure latches the log failed, like a rejected
+     * commit: a half-synced tree under a discarded log cannot be recovered.
+     */
+    checkpoint(): Promise<void>;
+    /**
+     * Give back one reference. The last release waits for the commit in flight and for a checkpoint
+     * in flight, runs a final checkpoint, closes the log handle and removes the lock; a log acquired
+     * for the directory meanwhile opens after that. Rejects only when that final checkpoint fails,
+     * and lets go of the handle and the lock either way.
+     */
+    release(): Promise<void>;
+    private throwIfFailed;
+    private enqueue;
+    private noteDifferingSettings;
+    private openOnce;
+    /**
+     * Apply the sealed segment's records, then the current log's, in order; make what they touched
+     * durable; then remove the sealed segment. The two files are one log: a sealed segment that
+     * stops short ends the replay there, and the current log is discarded with the rest of it.
+     *
+     * Re-applying a sealed segment whose checkpoint already synced the tree is harmless, because the
+     * current log holds every later write of the same paths, in order, and is applied after it. What
+     * must never happen is the sealed segment outliving the current log's truncation, since replaying
+     * it alone would put older content over newer: so the sealed segment is removed, and the
+     * directory synced, before {@link openOnce} truncates the current log. (On win32, where
+     * {@link fsyncDir} is skipped, NTFS commits the unlink and the later truncation through its
+     * metadata journal in order.)
+     */
+    private replay;
+    /** Apply one log file's intact records, in order, into `touched`. */
+    private replaySegment;
+    /** Create (or truncate) the current log to its header, and make it and its directory entry durable before any record goes in. */
+    private createEmptyLog;
+    /**
+     * Append the batch as one record. The record has reached the operating system when this
+     * resolves, so it survives a crash of this process: the next open's replay applies it. A failed
+     * append latches the log, and rejects every batch still waiting for its sync, since no sync will
+     * ever be made for them.
+     */
+    private append;
+    /**
+     * The sync step: one sync of the log makes every record appended so far durable; then each waiting
+     * batch is written to the tree, in order, and its `durable` resolved, in order. Called only from a
+     * queued task — a commit, {@link sync}, the timer's task or a checkpoint's seal — so it covers
+     * exactly the records appended before that task began, and a sealed segment only ever holds
+     * synced records whose tree writes are done. Nothing waiting: nothing is touched.
+     *
+     * A failure anywhere latches the log and rejects every covered `durable`, the ones whose tree
+     * write succeeded included: the records are durable and the next open's replay rebuilds the tree
+     * from them, but a `durable` is a promise that this process finished the work, and it did not.
+     *
+     * `owedSince` is the moment the timer fired, when the timer's task runs this: `SyncDeadlines.take`
+     * counts the sync's lateness from it rather than from a deadline the timer's own slop missed, and
+     * the cover says `window-overrun` once per episode of syncs that started late.
+     */
+    private syncUnsynced;
+    /** The timer fired: run the sync step in the queue. Its failure has latched the log, so it is only logged here, like a background checkpoint's. */
+    private syncInBackground;
+    /**
+     * Latch the log failed on its first fault and reject every batch waiting for a sync that will now
+     * never be made, so no caller waits on a `durable` for ever. Returns the error to throw.
+     */
+    private latch;
+    /**
+     * Write each entry to its canonical path, creating missing directories; record what the tree was given.
+     *
+     * NOTE: the write goes straight to the canonical path, so a reader of that path can see it
+     * half-written. The committing store's own readers are served from its overlay until the batch's
+     * `durable` resolves, and the two store kinds over one directory never share a path, so only a
+     * second store of the same kind over the same directory can read a torn file — a shape Invariant
+     * 5 already excludes. If that shape is ever supported, write through a temp file and rename.
+     */
+    private applyBatch;
+    /**
+     * `mkdir` created at least `dir`'s topmost missing ancestor, whose parent's entry is new too, so
+     * every directory from `dir` up to the store's root is marked — a superset of what was created,
+     * at most the layout's depth of extra directory syncs per checkpoint. (The created path `mkdir`
+     * returns is not compared against: on win32 it comes back in `\\?\` long-path form.)
+     */
+    private noteCreated;
+    /**
+     * After an append: re-arm the idle checkpoint, and start one now when the log has passed its size
+     * threshold. Nothing once the last release has begun, since it runs the final checkpoint itself.
+     */
+    private scheduleCheckpoint;
+    /** Never awaited by a commit: a commit holds the queue the checkpoint's seal waits in. Its failure has latched the log. */
+    private checkpointInBackground;
+    private disarmIdleCheckpoint;
+    private runCheckpoints;
+    /**
+     * 1. **Seal**, in the commit queue so no apply is in flight: run the sync step for whatever is
+     *    still waiting, rename the log to {@link SEALED_WRITE_LOG_FILENAME} and start an empty one, and
+     *    take the dirty set, leaving an empty one. Commits resume on the new log at once; only this
+     *    step waits in the queue.
+     * 2. **Sync**, off the commit path: every file in the taken set, then every directory. A file
+     *    deleted since is skipped; one rewritten since is synced with its newer content, which the
+     *    new log covers too.
+     * 3. **Truncate**: unlink the sealed segment and sync the directory.
+     *
+     * A crash anywhere in this leaves the sealed segment, the current log or both, and the next open
+     * replays them in that order (see {@link replay}).
+     */
+    private checkpointOnce;
+    /**
+     * Step 1 of {@link checkpointOnce}: the dirty set the sealed segment covers, or `undefined` when
+     * there is nothing to seal. The sync step runs first, so the sealed segment holds only synced
+     * records whose tree writes are in the set the checkpoint goes on to sync. An unsynced record
+     * always has bytes, so `appendedBytes` is never 0 while one waits: the early return cannot skip
+     * one, and the final checkpoint on the last release syncs whatever is still waiting.
+     */
+    private seal;
+    private shutDown;
+    private releaseResources;
+}
+//# sourceMappingURL=file-write-log.d.ts.map

package/dist/src/file-write-log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-write-log.d.ts","sourceRoot":"","sources":["../../src/file-write-log.ts"],"names":[],"mappings":"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"}