@zenfs/core 2.6.5 → 2.7.0

package/dist/vfs/sync.js

@@ -113,11 +113,11 @@ export function resolve($, path, preserveSymlinks, extra) {
  * @category VFS
  * @internal
  */
-export function open(path, opt) {
+export function open($, path, opt) {
     path = normalizePath(path);
     const mode = normalizeMode(opt.mode, 0o644), flag = flags.parse(opt.flag);
-    path = opt.preserveSymlinks ? path : resolve(this, path).fullPath;
-    const { fs, path: resolved } = resolveMount(path, this);
+    path = opt.preserveSymlinks ? path : resolve($, path).fullPath;
+    const { fs, path: resolved } = resolveMount(path, $);
     let stats;
     try {
         stats = fs.statSync(resolved);
@@ -134,25 +134,25 @@ export function open(path, opt) {
             // Create the file
             const parentPath = dirname(resolved);
             const parentStats = fs.statSync(parentPath);
-            if (checkAccess && !hasAccess(this, parentStats, constants.W_OK)) {
+            if (checkAccess && !hasAccess($, parentStats, constants.W_OK)) {
                 throw UV('EACCES', 'open', path);
             }
             if (!isDirectory(parentStats)) {
                 throw UV('ENOTDIR', 'open', path);
             }
-            if (!opt.allowDirectory && mode & constants.S_IFDIR)
+            if (!opt.allowDirectory && isDirectory({ mode }))
                 throw UV('EISDIR', 'open', path);
             // Serialize entry creation with other operations on the parent directory
             const _ = __addDisposableResource(env_1, lockPathSync(fs, parentPath, 'rw', parentStats), false);
-            const { euid: uid, egid: gid } = contextOf(this).credentials;
+            const { euid: uid, egid: gid } = contextOf($).credentials;
             const inode = fs.createFileSync(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(this, 'rename', path);
-            return new Handle(this, path, resolved, flag, cacheOf(fs).ref(resolved, inode));
+            emitChange($, 'rename', path);
+            return new Handle($, path, resolved, flag, cacheOf(fs).ref(resolved, inode));
         }
         catch (e_1) {
             env_1.error = e_1;
@@ -162,14 +162,14 @@ export function open(path, opt) {
             __disposeResources(env_1);
         }
     }
-    if (checkAccess && (!hasAccess(this, stats, mode) || !hasAccess(this, stats, flags.toMode(flag)))) {
+    if (checkAccess && (!hasAccess($, stats, mode) || !hasAccess($, stats, flags.toMode(flag)))) {
         throw UV('EACCES', 'open', path);
     }
     if (flag & constants.O_EXCL)
         throw UV('EEXIST', 'open', path);
-    if (!opt.allowDirectory && stats.mode & constants.S_IFDIR)
+    if (!opt.allowDirectory && isDirectory(stats))
         throw UV('EISDIR', 'open', path);
-    const file = new Handle(this, path, resolved, flag, cacheOf(fs).ref(resolved, stats));
+    const file = new Handle($, path, resolved, flag, cacheOf(fs).ref(resolved, stats));
     if (flag & constants.O_TRUNC)
         file.truncateSync(0);
     return file;

package/dist/vfs/vcache.js

@@ -50,6 +50,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
+import { err } from 'kerium/log';
 import { VNode } from './vnode.js';
 /**
  * The VFS-level cache of vnodes for a single file system. Modeled after Linux's dcache/icache.
@@ -76,6 +77,8 @@ export class VCache {
      */
     ref(path, inode) {
         let node = this.byIno.get(inode.ino);
+        if (node && node.inode.nlink === node.paths.size && !node.paths.has(path))
+            err(`vcache.ref: vnode for ${this.fs.label || this.fs.uuid}:${inode.ino} has an nlink of ${node.inode.nlink} but referenced by more paths [#314]`);
         if (!node) {
             node = new VNode(this.fs, path, inode);
             this.byIno.set(inode.ino, node);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "2.6.5",
+	"version": "2.7.0",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",
@@ -93,5 +93,14 @@
 		"typedoc": "^0.28.18",
 		"typescript": "^6.0.0",
 		"typescript-eslint": "^8.58.0"
+	},
+	"prettier": {
+		"singleQuote": true,
+		"useTabs": true,
+		"trailingComma": "es5",
+		"tabWidth": 4,
+		"printWidth": 150,
+		"arrowParens": "avoid",
+		"experimentalOperatorPosition": "start"
 	}
 }

package/scripts/make-index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { lstatSync, readdirSync, writeFileSync, constants as c } from 'node:fs';
+import { constants as c, lstatSync, readdirSync, writeFileSync } from 'node:fs';
 import { join, matchesGlob, relative, resolve } from 'node:path/posix';
 import { parseArgs, styleText } from 'node:util';
 
@@ -9,6 +9,7 @@ const { values: options, positionals } = parseArgs({
 		ignore: { short: 'i', type: 'string', multiple: true, default: [] },
 		output: { short: 'o', type: 'string', default: 'index.json' },
 		quiet: { short: 'q', type: 'boolean', default: false },
+		xdev: { type: 'boolean', default: false },
 		verbose: { type: 'boolean', default: false },
 	},
 	allowPositionals: true,
@@ -22,11 +23,12 @@ if (options.help) {
 path: The path to create a listing for
 
 options:
-	--help, -h		Outputs this help message
-	--quiet, -q		The command will not generate any output, including error messages.
-	--verbose		Output verbose messages
-	--output, -o <path>	Path to the output file. Defaults to listing.
-	--ignore, -i <pattern>	Ignores files which match the glob <pattern>. Can be passed multiple times.
+    -h, --help              Outputs this help message
+    -q, --quiet             The command will not generate any output, including error messages.
+        --verbose           Output verbose messages
+        --xdev              Force crossing device/FS boundaries
+    -o, --output <path>     Path to the output file. Defaults to listing.
+    -i, --ignore <pattern>  Ignores files which match the glob <pattern>. Can be passed multiple times.
 	`);
 	process.exit();
 }
@@ -75,6 +77,8 @@ function getTypeText(/** @type {{ mode: number }} */ stats) {
 	}
 }
 
+const seenDevs = new Set();
+
 /**
  * @param {string} path
  */
@@ -86,6 +90,17 @@ function computeEntries(path) {
 		}
 
 		const stats = lstatSync(path);
+		if (!seenDevs.size) seenDevs.add(stats.dev);
+		else if (!seenDevs.has(stats.dev))
+			if (options.xdev) {
+				console.warn(
+					`${styleText('yellowBright', `--xdev: Adding entries from device ${stats.dev} (${path}). You may get duplicate inos which MUST be de-duplicated manually.`)}`
+				);
+				seenDevs.add(stats.dev);
+			} else {
+				console.warn(`${styleText('yellowBright', `Ignoring ${path} because it crosses a device boundary`)}`);
+				return;
+			}
 
 		const type = getTypeText(stats);
 
@@ -97,7 +112,7 @@ function computeEntries(path) {
 		}
 	} catch (/** @type {any} */ e) {
 		if (!options.quiet) {
-			console.log(`${styleText('red', 'fail')} ${path}: ${e.message}`);
+			console.log(`${styleText('red', 'fail')} ${path}: ${e instanceof Error ? e.message : String(e)}`);
 		}
 	}
 }

package/tests/backend/cow.test.ts

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+import { CopyOnWriteFS, InMemoryStore, StoreFS } from '@zenfs/core';
+import assert from 'node:assert/strict';
+import { suite, test } from 'node:test';
+import { setupLogs } from '../logs.js';
+setupLogs();
+
+const size = 1 << 20;
+
+const options = { mode: 0o644, uid: 0, gid: 0 };
+
+suite('CopyOnWrite', () => {
+	test('Truncating a base-layer file does not copy up the bytes it discards #313', async () => {
+		const readable = new StoreFS(new InMemoryStore(undefined, 'ro'));
+		await readable.ready();
+		await readable.createFile('/big', options);
+		await readable.write('/big', new Uint8Array(size).fill(0x41), 0);
+
+		const writable = new StoreFS(new InMemoryStore(undefined, 'rw'));
+		await writable.ready();
+
+		const fs = new CopyOnWriteFS(readable, writable);
+		await fs.touch('/big', { ...(await fs.stat('/big')), size: 4 });
+
+		assert.equal((await fs.stat('/big')).size, 4);
+
+		await using tx = writable.transaction();
+		const data = (await tx.get((await writable.stat('/big')).data))!;
+
+		assert.equal(data.byteLength, 4);
+		assert.equal(data.buffer.byteLength, 4);
+	});
+});

package/tests/backend/fetch.test.ts

@@ -68,6 +68,14 @@ suite('CopyOnWrite over uncached Fetch #301', () => {
 		// Writes go through the vnode cache, so this surfaces when the handle is flushed rather than at `write`.
 		assert.throws(() => fs.fsyncSync(fd), { code: 'EAGAIN' });
 	});
+
+	test('Contents follow the size across the layers #313', async () => {
+		await fs.promises.truncate('/cow/a1.js', 4);
+		assert.equal(await fs.promises.readFile('/cow/a1.js', 'utf8'), '// C');
+
+		await fs.promises.truncate('/cow/a1.js', 10);
+		assert.equal(await fs.promises.readFile('/cow/a1.js', 'utf8'), '// C\0\0\0\0\0\0');
+	});
 });
 
 after(async () => {

package/tests/fs/truncate.test.ts

@@ -34,6 +34,17 @@ suite('Truncating', config('truncate'), () => {
 		fs.closeSync(fd);
 	});
 
+	test('Contents follow the size #313', config('sync'), () => {
+		const path = 'truncate-contents.txt';
+		fs.writeFileSync(path, 'SECRETDATA');
+
+		fs.truncateSync(path, 4);
+		assert.equal(fs.readFileSync(path, 'utf8'), 'SECR');
+
+		fs.truncateSync(path, 10);
+		assert.equal(fs.readFileSync(path, 'utf8'), 'SECR\0\0\0\0\0\0');
+	});
+
 	const statSize = async (path: string) => (await fs.promises.stat(path)).size;
 
 	test('Async path functions', config('async'), async () => {
@@ -64,4 +75,15 @@ suite('Truncating', config('truncate'), () => {
 
 		await handle.close();
 	});
+
+	test('Contents follow the size (async) #313', config('async'), async () => {
+		const path = 'truncate-contents-async.txt';
+		await fs.promises.writeFile(path, 'SECRETDATA');
+
+		await fs.promises.truncate(path, 4);
+		assert.equal(await fs.promises.readFile(path, 'utf8'), 'SECR');
+
+		await fs.promises.truncate(path, 10);
+		assert.equal(await fs.promises.readFile(path, 'utf8'), 'SECR\0\0\0\0\0\0');
+	});
 });