@zenfs/core 2.5.8 → 2.6.0

package/dist/vfs/async.js

@@ -1,3 +1,55 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { rethrow, setUVMessage, UV } from 'kerium';
 import { decodeUTF8 } from 'utilium';
 import * as constants from '../constants.js';
@@ -10,6 +62,7 @@ import { Dirent, ifToDt } from './dir.js';
 import { Handle } from './file.js';
 import * as flags from './flags.js';
 import { resolveMount } from './shared.js';
+import { cacheOf, lockPath } from './vcache.js';
 import { emitChange } from './watchers.js';
 /**
  * Resolves the mount and real path for a path.
@@ -20,15 +73,15 @@ export async function resolve($, path, preserveSymlinks, extra) {
     path = resolvePath.call($, path);
     if (preserveSymlinks) {
         const resolved = resolveMount(path, $, extra);
-        const stats = await resolved.fs.stat(resolved.path).catch(() => undefined);
+        const stats = cacheOf(resolved.fs).get(resolved.path)?.inode ?? (await resolved.fs.stat(resolved.path).catch(() => undefined));
         return { ...resolved, fullPath: path, stats };
     }
     /* Try to resolve it directly. If this works,
     that means we don't need to perform any resolution for parent directories. */
     try {
         const resolved = resolveMount(path, $);
-        // Stat it to make sure it exists
-        const stats = await resolved.fs.stat(resolved.path);
+        // Stat it to make sure it exists. The vnode cache takes precedence since it may have unsynced changes
+        const stats = cacheOf(resolved.fs).get(resolved.path)?.inode ?? (await resolved.fs.stat(resolved.path));
         if (!isSymbolicLink(stats)) {
             return { ...resolved, fullPath: path, stats };
         }
@@ -42,11 +95,12 @@ export async function resolve($, path, preserveSymlinks, extra) {
     const realDir = dir == '/' ? '/' : (await resolve($, dir, false, extra)).fullPath;
     const maybePath = join(realDir, base);
     const resolved = resolveMount(maybePath, $);
-    const stats = await resolved.fs.stat(resolved.path).catch((e) => {
-        if (e.code == 'ENOENT')
-            return;
-        throw setUVMessage(Object.assign(e, { syscall: 'stat', path: maybePath, ...extra }));
-    });
+    const stats = cacheOf(resolved.fs).get(resolved.path)?.inode
+        ?? (await resolved.fs.stat(resolved.path).catch((e) => {
+            if (e.code == 'ENOENT')
+                return;
+            throw setUVMessage(Object.assign(e, { syscall: 'stat', path: maybePath, ...extra }));
+        }));
     if (!stats)
         return { ...resolved, fullPath: path };
     if (!isSymbolicLink(stats)) {
@@ -63,33 +117,53 @@ export async function open($, path, opt) {
     path = normalizePath(path);
     const mode = normalizeMode(opt.mode, 0o644), flag = flags.parse(opt.flag);
     const $ex = { syscall: 'open', path };
-    const { fs, path: resolved, stats } = await resolve($, path, opt.preserveSymlinks, $ex);
+    // eslint-disable-next-line prefer-const
+    let { fs, path: resolved, stats } = await resolve($, path, opt.preserveSymlinks, $ex);
     if (!stats) {
-        if (!(flag & constants.O_CREAT))
-            throw UV('ENOENT', $ex);
-        // Create the file
-        const parentStats = await fs.stat(dirname(resolved));
-        if (checkAccess && !hasAccess($, parentStats, constants.W_OK))
-            throw UV('EACCES', 'open', dirname(path));
-        if (!isDirectory(parentStats))
-            throw UV('ENOTDIR', 'open', dirname(path));
-        if (!opt.allowDirectory && mode & constants.S_IFDIR)
-            throw UV('EISDIR', 'open', path);
-        const { euid: uid, egid: gid } = contextOf($).credentials;
-        const inode = await fs.createFile(resolved, {
-            mode,
-            uid: parentStats.mode & constants.S_ISUID ? parentStats.uid : uid,
-            gid: parentStats.mode & constants.S_ISGID ? parentStats.gid : gid,
-        });
-        return new Handle($, path, fs, resolved, flag, inode);
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            if (!(flag & constants.O_CREAT))
+                throw UV('ENOENT', $ex);
+            // Create the file
+            const parentPath = dirname(resolved);
+            const parentStats = await fs.stat(parentPath);
+            if (checkAccess && !hasAccess($, parentStats, constants.W_OK))
+                throw UV('EACCES', 'open', dirname(path));
+            if (!isDirectory(parentStats))
+                throw UV('ENOTDIR', 'open', dirname(path));
+            if (!opt.allowDirectory && mode & constants.S_IFDIR)
+                throw UV('EISDIR', 'open', path);
+            // Serialize entry creation with other operations on the parent directory
+            const _ = __addDisposableResource(env_1, await lockPath(fs, parentPath, 'rw', parentStats), false);
+            // Another task may have created the file while we waited for the lock
+            stats = cacheOf(fs).get(resolved)?.inode ?? (await fs.stat(resolved).catch(() => undefined));
+            if (!stats) {
+                const { euid: uid, egid: gid } = contextOf($).credentials;
+                const inode = await fs.createFile(resolved, {
+                    mode,
+                    uid: parentStats.mode & constants.S_ISUID ? parentStats.uid : uid,
+                    gid: parentStats.mode & constants.S_ISGID ? parentStats.gid : gid,
+                });
+                // A new entry in the parent directory, which is a 'rename' event
+                emitChange($, 'rename', path);
+                return new Handle($, path, resolved, flag, cacheOf(fs).ref(resolved, inode));
+            }
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
+        }
     }
     if (checkAccess && !hasAccess($, stats, flags.toMode(flag)))
         throw UV('EACCES', $ex);
     if (flag & constants.O_EXCL)
         throw UV('EEXIST', $ex);
-    const handle = new Handle($, path, fs, resolved, flag, stats);
     if (!opt.allowDirectory && mode & constants.S_IFDIR)
         throw UV('EISDIR', 'open', path);
+    const handle = new Handle($, path, resolved, flag, cacheOf(fs).ref(resolved, stats));
     if (flag & constants.O_TRUNC)
         await handle.truncate(0);
     return handle;
@@ -115,15 +189,28 @@ export async function mkdir(path, options = {}) {
     const { mode = 0o777, recursive } = options;
     const { fs, path: resolved } = resolveMount(path, this, { syscall: 'mkdir' });
     const __create = async (path, resolved, parent) => {
-        if (checkAccess && !hasAccess(this, parent, constants.W_OK))
-            throw UV('EACCES', 'mkdir', path);
-        const inode = await fs.mkdir(resolved, {
-            mode,
-            uid: parent.mode & constants.S_ISUID ? parent.uid : uid,
-            gid: parent.mode & constants.S_ISGID ? parent.gid : gid,
-        });
-        emitChange(this, 'rename', path);
-        return inode;
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            if (checkAccess && !hasAccess(this, parent, constants.W_OK))
+                throw UV('EACCES', 'mkdir', path);
+            const _ = __addDisposableResource(env_2, await lockPath(fs, dirname(resolved), 'rw', parent), false);
+            const inode = await fs
+                .mkdir(resolved, {
+                mode,
+                uid: parent.mode & constants.S_ISUID ? parent.uid : uid,
+                gid: parent.mode & constants.S_ISGID ? parent.gid : gid,
+            })
+                .catch(rethrow({ syscall: 'mkdir', path }));
+            emitChange(this, 'rename', path);
+            return inode;
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            __disposeResources(env_2);
+        }
     };
     if (!recursive) {
         await __create(path, resolved, await fs.stat(dirname(resolved)));
@@ -144,7 +231,8 @@ export async function mkdir(path, options = {}) {
 }
 export async function readdir(path, options = {}) {
     path = normalizePath(path);
-    const $ex = { syscall: 'readdir', path };
+    // Node reports `readdir` failures as `scandir`
+    const $ex = { syscall: 'scandir', path };
     const { fs, path: resolved, stats } = await resolve(this, path, false, $ex);
     if (!stats)
         throw UV('ENOENT', $ex);
@@ -152,7 +240,21 @@ export async function readdir(path, options = {}) {
         throw UV('EACCES', $ex);
     if (!isDirectory(stats))
         throw UV('ENOTDIR', $ex);
-    const entries = await fs.readdir(resolved);
+    let entries;
+    {
+        const env_3 = { stack: [], error: void 0, hasError: false };
+        try {
+            const _ = __addDisposableResource(env_3, await lockPath(fs, resolved, 'ro', stats), false);
+            entries = await fs.readdir(resolved);
+        }
+        catch (e_3) {
+            env_3.error = e_3;
+            env_3.hasError = true;
+        }
+        finally {
+            __disposeResources(env_3);
+        }
+    }
     const values = [];
     const addEntry = async (entry) => {
         const entryStats = await fs.stat(join(resolved, entry)).catch((e) => {
@@ -178,55 +280,91 @@ export async function readdir(path, options = {}) {
     return values;
 }
 export async function rename(oldPath, newPath) {
-    oldPath = normalizePath(oldPath);
-    newPath = normalizePath(newPath);
-    const $ex = { syscall: 'rename', path: oldPath, dest: newPath };
-    const src = await resolve(this, oldPath, true, $ex);
-    const dst = resolveMount(newPath, this, $ex);
-    if (src.fs.uuid !== dst.fs.uuid)
-        throw UV('EXDEV', $ex);
-    if (dst.path.startsWith(src.path + '/'))
-        throw UV('EBUSY', $ex);
-    if (!src.stats)
-        throw UV('ENOENT', $ex);
-    const fs = src.fs;
-    const oldParent = await fs.stat(dirname(src.path));
-    const newParent = await fs.stat(dirname(dst.path));
-    const newStats = await fs.stat(dst.path).catch((e) => {
-        if (e.code == 'ENOENT')
-            return null;
-        throw e;
-    });
-    if (checkAccess && (!hasAccess(this, oldParent, constants.R_OK) || !hasAccess(this, newParent, constants.W_OK)))
-        throw UV('EACCES', $ex);
-    if (newStats && !isDirectory(src.stats) && isDirectory(newStats))
-        throw UV('EISDIR', $ex);
-    if (newStats && isDirectory(src.stats) && !isDirectory(newStats))
-        throw UV('ENOTDIR', $ex);
-    await src.fs.rename(src.path, dst.path);
-    emitChange(this, 'rename', oldPath);
-    emitChange(this, 'change', newPath);
+    const env_4 = { stack: [], error: void 0, hasError: false };
+    try {
+        oldPath = normalizePath(oldPath);
+        newPath = normalizePath(newPath);
+        const $ex = { syscall: 'rename', path: oldPath, dest: newPath };
+        const src = await resolve(this, oldPath, true, $ex);
+        const dst = resolveMount(newPath, this, $ex);
+        if (src.fs.uuid !== dst.fs.uuid)
+            throw UV('EXDEV', $ex);
+        // A directory can not be moved inside itself
+        if (dst.path.startsWith(src.path + '/'))
+            throw UV('EINVAL', $ex);
+        if (!src.stats)
+            throw UV('ENOENT', $ex);
+        const fs = src.fs;
+        const oldParent = await fs.stat(dirname(src.path));
+        const newParent = await fs.stat(dirname(dst.path));
+        const newStats = await fs.stat(dst.path).catch((e) => {
+            if (e.code == 'ENOENT')
+                return null;
+            throw e;
+        });
+        if (checkAccess && (!hasAccess(this, oldParent, constants.R_OK) || !hasAccess(this, newParent, constants.W_OK)))
+            throw UV('EACCES', $ex);
+        if (newStats && !isDirectory(src.stats) && isDirectory(newStats))
+            throw UV('EISDIR', $ex);
+        if (newStats && isDirectory(src.stats) && !isDirectory(newStats))
+            throw UV('ENOTDIR', $ex);
+        const srcDir = dirname(src.path);
+        const dstDir = dirname(dst.path);
+        // Lock both parent directories, ordered by inode number to avoid ABBA deadlocks (like Linux's `lock_two_nondirectories`)
+        const parents = [
+            [srcDir, oldParent],
+            [dstDir, newParent],
+        ];
+        if (oldParent.ino > newParent.ino)
+            parents.reverse();
+        const _first = __addDisposableResource(env_4, await lockPath(fs, parents[0][0], 'rw', parents[0][1]), false);
+        const _second = __addDisposableResource(env_4, oldParent.ino == newParent.ino ? null : await lockPath(fs, parents[1][0], 'rw', parents[1][1]), false);
+        await src.fs.rename(src.path, dst.path);
+        cacheOf(fs).rename(src.path, dst.path);
+        // Both names change which entries exist, so both are 'rename' events
+        emitChange(this, 'rename', oldPath);
+        emitChange(this, 'rename', newPath);
+    }
+    catch (e_4) {
+        env_4.error = e_4;
+        env_4.hasError = true;
+    }
+    finally {
+        __disposeResources(env_4);
+    }
 }
 export async function link(target, link) {
-    target = normalizePath(target);
-    link = normalizePath(link);
-    const $ex = { syscall: 'link', path: link, dest: target };
-    const { fs, path: resolved } = resolveMount(target, this, $ex);
-    const dst = resolveMount(link, this, $ex);
-    if (fs.uuid != dst.fs.uuid)
-        throw UV('EXDEV', $ex);
-    const stats = await fs.stat(resolved);
-    if (checkAccess) {
-        if (!hasAccess(this, stats, constants.R_OK))
-            throw UV('EACCES', $ex);
-        const dirStats = await fs.stat(dirname(resolved));
-        if (!hasAccess(this, dirStats, constants.R_OK))
-            throw UV('EACCES', $ex);
-        const destStats = await fs.stat(dirname(dst.path));
-        if (!hasAccess(this, destStats, constants.W_OK))
-            throw UV('EACCES', $ex);
+    const env_5 = { stack: [], error: void 0, hasError: false };
+    try {
+        target = normalizePath(target);
+        link = normalizePath(link);
+        const $ex = { syscall: 'link', path: target, dest: link };
+        const { fs, path: resolved } = resolveMount(target, this, $ex);
+        const dst = resolveMount(link, this, $ex);
+        if (fs.uuid != dst.fs.uuid)
+            throw UV('EXDEV', $ex);
+        const stats = await fs.stat(resolved);
+        if (checkAccess) {
+            if (!hasAccess(this, stats, constants.R_OK))
+                throw UV('EACCES', $ex);
+            const dirStats = await fs.stat(dirname(resolved));
+            if (!hasAccess(this, dirStats, constants.R_OK))
+                throw UV('EACCES', $ex);
+            const destStats = await fs.stat(dirname(dst.path));
+            if (!hasAccess(this, destStats, constants.W_OK))
+                throw UV('EACCES', $ex);
+        }
+        const _ = __addDisposableResource(env_5, await lockPath(fs, dirname(dst.path), 'rw'), false);
+        await fs.link(resolved, dst.path);
+        cacheOf(fs).link(resolved, dst.path);
+    }
+    catch (e_5) {
+        env_5.error = e_5;
+        env_5.hasError = true;
+    }
+    finally {
+        __disposeResources(env_5);
     }
-    return await fs.link(resolved, dst.path);
 }
 export async function stat(path, lstat) {
     path = normalizePath.call(this, path);
@@ -237,7 +375,8 @@ export async function stat(path, lstat) {
     else {
         const { base, dir } = parse(path);
         const { fs, path: parent } = await resolve(this, dir, false, extra);
-        stats = await fs.stat(base ? join(parent, base) : parent).catch(rethrow(extra));
+        const target = base ? join(parent, base) : parent;
+        stats = cacheOf(fs).get(target)?.inode ?? (await fs.stat(target).catch(rethrow(extra)));
     }
     if (!stats)
         throw UV('ENOENT', extra);

package/dist/vfs/file.d.ts

@@ -2,6 +2,7 @@ import type { V_Context } from '../context.js';
 import type { FileSystem, StreamOptions } from '../internal/filesystem.js';
 import { type InodeLike } from '../internal/inode.js';
 import '../polyfills.js';
+import type { VNode } from './vnode.js';
 /** @hidden */
 export interface FileReadResult<T extends ArrayBufferView> {
     bytesRead: number;
@@ -13,11 +14,9 @@ export interface FileReadResult<T extends ArrayBufferView> {
 export declare class Handle {
     readonly context: V_Context;
     readonly path: string;
-    readonly fs: FileSystem;
     readonly internalPath: string;
     readonly flag: number;
-    readonly inode: InodeLike;
-    protected _buffer?: Uint8Array;
+    readonly vnode: VNode;
     /**
      * Current position
      */
@@ -33,20 +32,24 @@ export declare class Handle {
      */
     get position(): number;
     set position(value: number);
+    /**
+     * The inode for the file. This is shared between all handles for the file via the vnode.
+     */
+    get inode(): InodeLike;
+    get fs(): FileSystem;
     /**
      * Whether the file has changes which have not been written to the FS
      */
-    protected dirty: boolean;
+    protected get dirty(): boolean;
     /**
      * Whether the file is open or closed
      */
     protected closed: boolean;
     get isClosed(): boolean;
     /**
-     * Creates a file with `path` and, optionally, the given contents.
-     * Note that, if contents is specified, it will be mutated by the file.
+     * Creates a file handle for the vnode.
      */
-    constructor(context: V_Context, path: string, fs: FileSystem, internalPath: string, flag: number, inode: InodeLike);
+    constructor(context: V_Context, path: string, internalPath: string, flag: number, vnode: VNode);
     protected get _isSync(): boolean;
     [Symbol.dispose](): void;
     syncSync(): void;
@@ -127,10 +130,13 @@ export declare class Handle {
     utimes(atime: number, mtime: number): Promise<void>;
     /**
      * Create a stream for reading the file.
+     * @todo Don't repeat ourselves with the implementation in `FileSystem`
      */
     streamRead(options: StreamOptions): ReadableStream;
     /**
      * Create a stream for writing the file.
+     * Chunks are written to the vnode's cache, then synced when the stream is closed.
+     * @todo Don't repeat ourselves with the implementation in `FileSystem`
      */
     streamWrite(options: StreamOptions): WritableStream;
 }