@zenfs/core 0.9.7 → 0.11.0

package/dist/backends/AsyncStore.js

@@ -1,509 +0,0 @@
-import { dirname, basename, join, resolve } from '../emulation/path.js';
-import { ApiError, ErrorCode } from '../ApiError.js';
-import { W_OK, R_OK } from '../emulation/constants.js';
-import { PreloadFile, flagToMode } from '../file.js';
-import { Async, FileSystem } from '../filesystem.js';
-import { randomIno, Inode } from '../inode.js';
-import { FileType } from '../stats.js';
-import { encode, decodeDirListing, encodeDirListing } from '../utils.js';
-import { rootIno } from '../inode.js';
-import { InMemory } from './InMemory.js';
-/**
- * Last Recently Used cache
- */
-class LRUCache {
-    constructor(limit) {
-        this.limit = limit;
-        this.cache = [];
-    }
-    set(key, value) {
-        const existingIndex = this.cache.findIndex(node => node.key === key);
-        if (existingIndex != -1) {
-            this.cache.splice(existingIndex, 1);
-        }
-        else if (this.cache.length >= this.limit) {
-            this.cache.shift();
-        }
-        this.cache.push({ key, value });
-    }
-    get(key) {
-        const node = this.cache.find(n => n.key === key);
-        if (!node) {
-            return;
-        }
-        // Move the accessed item to the end of the cache (most recently used)
-        this.set(key, node.value);
-        return node.value;
-    }
-    remove(key) {
-        const index = this.cache.findIndex(node => node.key === key);
-        if (index !== -1) {
-            this.cache.splice(index, 1);
-        }
-    }
-    reset() {
-        this.cache = [];
-    }
-}
-/**
- * An asynchronous file system which uses an async store to store its data.
- * @see AsyncStore
- * @internal
- */
-export class AsyncStoreFS extends Async(FileSystem) {
-    get store() {
-        if (!this._store) {
-            throw new ReferenceError('AsyncStoreFS not attached to a store');
-        }
-        return this._store;
-    }
-    async ready() {
-        if (this._initialized) {
-            return this;
-        }
-        this._initialized = true;
-        if (this._options.lruCacheSize) {
-            this._cache = new LRUCache(this._options.lruCacheSize);
-        }
-        this._store = await this._options.store;
-        this._sync = this._options.sync || this._sync;
-        await this.makeRootDirectory();
-        await super.ready();
-        return this;
-    }
-    metadata() {
-        return {
-            ...super.metadata(),
-            name: this.store.name,
-        };
-    }
-    constructor(_options) {
-        super();
-        this._options = _options;
-        this._initialized = false;
-        this._sync = InMemory.create({ name: 'test' });
-    }
-    /**
-     * Delete all contents stored in the file system.
-     */
-    async empty() {
-        if (this._cache) {
-            this._cache.reset();
-        }
-        await this.store.clear();
-        // Root always exists.
-        await this.makeRootDirectory();
-    }
-    /**
-     * @todo Make rename compatible with the cache.
-     */
-    async rename(oldPath, newPath, cred) {
-        await this.queueDone();
-        const c = this._cache;
-        if (this._cache) {
-            // Clear and disable cache during renaming process.
-            delete this._cache;
-            c?.reset();
-        }
-        try {
-            const tx = this.store.beginTransaction(), oldParent = dirname(oldPath), oldName = basename(oldPath), newParent = dirname(newPath), newName = basename(newPath), 
-            // Remove oldPath from parent's directory listing.
-            oldDirNode = await this.findINode(tx, oldParent), oldDirList = await this.getDirListing(tx, oldDirNode, oldParent);
-            if (!oldDirNode.toStats().hasAccess(W_OK, cred)) {
-                throw ApiError.With('EACCES', oldPath, 'rename');
-            }
-            if (!oldDirList[oldName]) {
-                throw ApiError.With('ENOENT', oldPath, 'rename');
-            }
-            const nodeId = oldDirList[oldName];
-            delete oldDirList[oldName];
-            // Invariant: Can't move a folder inside itself.
-            // This funny little hack ensures that the check passes only if oldPath
-            // is a subpath of newParent. We append '/' to avoid matching folders that
-            // are a substring of the bottom-most folder in the path.
-            if ((newParent + '/').indexOf(oldPath + '/') === 0) {
-                throw new ApiError(ErrorCode.EBUSY, oldParent);
-            }
-            // Add newPath to parent's directory listing.
-            let newDirNode, newDirList;
-            if (newParent === oldParent) {
-                // Prevent us from re-grabbing the same directory listing, which still
-                // contains oldName.
-                newDirNode = oldDirNode;
-                newDirList = oldDirList;
-            }
-            else {
-                newDirNode = await this.findINode(tx, newParent);
-                newDirList = await this.getDirListing(tx, newDirNode, newParent);
-            }
-            if (newDirList[newName]) {
-                // If it's a file, delete it.
-                const newNameNode = await this.getINode(tx, newDirList[newName], newPath);
-                if (newNameNode.toStats().isFile()) {
-                    try {
-                        await tx.remove(newNameNode.ino);
-                        await tx.remove(newDirList[newName]);
-                    }
-                    catch (e) {
-                        await tx.abort();
-                        throw e;
-                    }
-                }
-                else {
-                    // If it's a directory, throw a permissions error.
-                    throw ApiError.With('EPERM', newPath, 'rename');
-                }
-            }
-            newDirList[newName] = nodeId;
-            // Commit the two changed directory listings.
-            try {
-                await tx.put(oldDirNode.ino, encodeDirListing(oldDirList), true);
-                await tx.put(newDirNode.ino, encodeDirListing(newDirList), true);
-            }
-            catch (e) {
-                await tx.abort();
-                throw e;
-            }
-            await tx.commit();
-        }
-        finally {
-            if (c) {
-                this._cache = c;
-            }
-        }
-    }
-    async stat(p, cred) {
-        await this.queueDone();
-        const tx = this.store.beginTransaction();
-        const inode = await this.findINode(tx, p);
-        if (!inode) {
-            throw ApiError.With('ENOENT', p, 'stat');
-        }
-        const stats = inode.toStats();
-        if (!stats.hasAccess(R_OK, cred)) {
-            throw ApiError.With('EACCES', p, 'stat');
-        }
-        return stats;
-    }
-    async createFile(p, flag, mode, cred) {
-        await this.queueDone();
-        const tx = this.store.beginTransaction(), data = new Uint8Array(0), newFile = await this.commitNewFile(tx, p, FileType.FILE, mode, cred, data);
-        // Open the file.
-        return new PreloadFile(this, p, flag, newFile.toStats(), data);
-    }
-    async openFile(p, flag, cred) {
-        await this.queueDone();
-        const tx = this.store.beginTransaction(), node = await this.findINode(tx, p), data = await tx.get(node.ino);
-        if (!node.toStats().hasAccess(flagToMode(flag), cred)) {
-            throw ApiError.With('EACCES', p, 'openFile');
-        }
-        if (!data) {
-            throw ApiError.With('ENOENT', p, 'openFile');
-        }
-        return new PreloadFile(this, p, flag, node.toStats(), data);
-    }
-    async unlink(p, cred) {
-        await this.queueDone();
-        return this.removeEntry(p, false, cred);
-    }
-    async rmdir(p, cred) {
-        await this.queueDone();
-        // Check first if directory is empty.
-        const list = await this.readdir(p, cred);
-        if (list.length > 0) {
-            throw ApiError.With('ENOTEMPTY', p, 'rmdir');
-        }
-        await this.removeEntry(p, true, cred);
-    }
-    async mkdir(p, mode, cred) {
-        await this.queueDone();
-        const tx = this.store.beginTransaction(), data = encode('{}');
-        await this.commitNewFile(tx, p, FileType.DIRECTORY, mode, cred, data);
-    }
-    async readdir(p, cred) {
-        await this.queueDone();
-        const tx = this.store.beginTransaction();
-        const node = await this.findINode(tx, p);
-        if (!node.toStats().hasAccess(R_OK, cred)) {
-            throw ApiError.With('EACCES', p, 'readdur');
-        }
-        return Object.keys(await this.getDirListing(tx, node, p));
-    }
-    /**
-     * Updated the inode and data node at the given path
-     * @todo Ensure mtime updates properly, and use that to determine if a data update is required.
-     */
-    async sync(p, data, stats) {
-        await this.queueDone();
-        const tx = this.store.beginTransaction(), 
-        // We use the _findInode helper because we actually need the INode id.
-        fileInodeId = await this._findINode(tx, dirname(p), basename(p)), fileInode = await this.getINode(tx, fileInodeId, p), inodeChanged = fileInode.update(stats);
-        try {
-            // Sync data.
-            await tx.put(fileInode.ino, data, true);
-            // Sync metadata.
-            if (inodeChanged) {
-                await tx.put(fileInodeId, fileInode.data, true);
-            }
-        }
-        catch (e) {
-            await tx.abort();
-            throw e;
-        }
-        await tx.commit();
-    }
-    async link(existing, newpath, cred) {
-        await this.queueDone();
-        const tx = this.store.beginTransaction(), existingDir = dirname(existing), existingDirNode = await this.findINode(tx, existingDir);
-        if (!existingDirNode.toStats().hasAccess(R_OK, cred)) {
-            throw ApiError.With('EACCES', existingDir, 'link');
-        }
-        const newDir = dirname(newpath), newDirNode = await this.findINode(tx, newDir), newListing = await this.getDirListing(tx, newDirNode, newDir);
-        if (!newDirNode.toStats().hasAccess(W_OK, cred)) {
-            throw ApiError.With('EACCES', newDir, 'link');
-        }
-        const ino = await this._findINode(tx, existingDir, basename(existing));
-        const node = await this.getINode(tx, ino, existing);
-        if (!node.toStats().hasAccess(W_OK, cred)) {
-            throw ApiError.With('EACCES', newpath, 'link');
-        }
-        node.nlink++;
-        newListing[basename(newpath)] = ino;
-        try {
-            tx.put(ino, node.data, true);
-            tx.put(newDirNode.ino, encodeDirListing(newListing), true);
-        }
-        catch (e) {
-            tx.abort();
-            throw e;
-        }
-        tx.commit();
-    }
-    /**
-     * Checks if the root directory exists. Creates it if it doesn't.
-     */
-    async makeRootDirectory() {
-        const tx = this.store.beginTransaction();
-        if (!(await tx.get(rootIno))) {
-            // Create new inode. o777, owned by root:root
-            const inode = new Inode();
-            inode.mode = 0o777 | FileType.DIRECTORY;
-            // If the root doesn't exist, the first random ID shouldn't exist either.
-            await tx.put(inode.ino, encode('{}'), false);
-            await tx.put(rootIno, inode.data, false);
-            await tx.commit();
-        }
-    }
-    /**
-     * Helper function for findINode.
-     * @param parent The parent directory of the file we are attempting to find.
-     * @param filename The filename of the inode we are attempting to find, minus
-     *   the parent.
-     */
-    async _findINode(tx, parent, filename, visited = new Set()) {
-        const currentPath = join(parent, filename);
-        if (visited.has(currentPath)) {
-            throw new ApiError(ErrorCode.EIO, 'Infinite loop detected while finding inode', currentPath);
-        }
-        visited.add(currentPath);
-        if (this._cache) {
-            const id = this._cache.get(currentPath);
-            if (id) {
-                return id;
-            }
-        }
-        if (parent === '/') {
-            if (filename === '') {
-                // BASE CASE #1: Return the root's ID.
-                if (this._cache) {
-                    this._cache.set(currentPath, rootIno);
-                }
-                return rootIno;
-            }
-            else {
-                // BASE CASE #2: Find the item in the root node.
-                const inode = await this.getINode(tx, rootIno, parent);
-                const dirList = await this.getDirListing(tx, inode, parent);
-                if (dirList[filename]) {
-                    const id = dirList[filename];
-                    if (this._cache) {
-                        this._cache.set(currentPath, id);
-                    }
-                    return id;
-                }
-                else {
-                    throw ApiError.With('ENOENT', resolve(parent, filename), '_findINode');
-                }
-            }
-        }
-        else {
-            // Get the parent directory's INode, and find the file in its directory
-            // listing.
-            const inode = await this.findINode(tx, parent, visited);
-            const dirList = await this.getDirListing(tx, inode, parent);
-            if (dirList[filename]) {
-                const id = dirList[filename];
-                if (this._cache) {
-                    this._cache.set(currentPath, id);
-                }
-                return id;
-            }
-            else {
-                throw ApiError.With('ENOENT', resolve(parent, filename), '_findINode');
-            }
-        }
-    }
-    /**
-     * Finds the Inode of the given path.
-     * @param p The path to look up.
-     * @todo memoize/cache
-     */
-    async findINode(tx, p, visited = new Set()) {
-        const id = await this._findINode(tx, dirname(p), basename(p), visited);
-        return this.getINode(tx, id, p);
-    }
-    /**
-     * Given the ID of a node, retrieves the corresponding Inode.
-     * @param tx The transaction to use.
-     * @param p The corresponding path to the file (used for error messages).
-     * @param id The ID to look up.
-     */
-    async getINode(tx, id, p) {
-        const data = await tx.get(id);
-        if (!data) {
-            throw ApiError.With('ENOENT', p, 'getINode');
-        }
-        return new Inode(data.buffer);
-    }
-    /**
-     * Given the Inode of a directory, retrieves the corresponding directory
-     * listing.
-     */
-    async getDirListing(tx, inode, p) {
-        if (!inode.toStats().isDirectory()) {
-            throw ApiError.With('ENOTDIR', p, 'getDirListing');
-        }
-        const data = await tx.get(inode.ino);
-        if (!data) {
-            /*
-                Occurs when data is undefined, or corresponds to something other
-                than a directory listing. The latter should never occur unless
-                the file system is corrupted.
-             */
-            throw ApiError.With('ENOENT', p, 'getDirListing');
-        }
-        return decodeDirListing(data);
-    }
-    /**
-     * Adds a new node under a random ID. Retries 5 times before giving up in
-     * the exceedingly unlikely chance that we try to reuse a random ino.
-     */
-    async addNewNode(tx, data, _maxAttempts = 5) {
-        if (_maxAttempts <= 0) {
-            // Max retries hit. Return with an error.
-            throw new ApiError(ErrorCode.EIO, 'Unable to commit data to key-value store.');
-        }
-        // Make an attempt
-        const ino = randomIno();
-        const isCommited = await tx.put(ino, data, false);
-        if (!isCommited) {
-            return await this.addNewNode(tx, data, --_maxAttempts);
-        }
-        return ino;
-    }
-    /**
-     * Commits a new file (well, a FILE or a DIRECTORY) to the file system with
-     * the given mode.
-     * Note: This will commit the transaction.
-     * @param p The path to the new file.
-     * @param type The type of the new file.
-     * @param mode The mode to create the new file with.
-     * @param cred The UID/GID to create the file with
-     * @param data The data to store at the file's data node.
-     */
-    async commitNewFile(tx, p, type, mode, cred, data) {
-        const parentDir = dirname(p), fname = basename(p), parentNode = await this.findINode(tx, parentDir), dirListing = await this.getDirListing(tx, parentNode, parentDir);
-        //Check that the creater has correct access
-        if (!parentNode.toStats().hasAccess(W_OK, cred)) {
-            throw ApiError.With('EACCES', p, 'commitNewFile');
-        }
-        // Invariant: The root always exists.
-        // If we don't check this prior to taking steps below, we will create a
-        // file with name '' in root should p == '/'.
-        if (p === '/') {
-            throw ApiError.With('EEXIST', p, 'commitNewFile');
-        }
-        // Check if file already exists.
-        if (dirListing[fname]) {
-            await tx.abort();
-            throw ApiError.With('EEXIST', p, 'commitNewFile');
-        }
-        try {
-            // Commit data.
-            const inode = new Inode();
-            inode.ino = await this.addNewNode(tx, data);
-            inode.mode = mode | type;
-            inode.uid = cred.uid;
-            inode.gid = cred.gid;
-            inode.size = data.length;
-            // Update and commit parent directory listing.
-            dirListing[fname] = await this.addNewNode(tx, inode.data);
-            await tx.put(parentNode.ino, encodeDirListing(dirListing), true);
-            await tx.commit();
-            return inode;
-        }
-        catch (e) {
-            tx.abort();
-            throw e;
-        }
-    }
-    /**
-     * Remove all traces of the given path from the file system.
-     * @param p The path to remove from the file system.
-     * @param isDir Does the path belong to a directory, or a file?
-     * @todo Update mtime.
-     */
-    /**
-     * Remove all traces of the given path from the file system.
-     * @param p The path to remove from the file system.
-     * @param isDir Does the path belong to a directory, or a file?
-     * @todo Update mtime.
-     */
-    async removeEntry(p, isDir, cred) {
-        if (this._cache) {
-            this._cache.remove(p);
-        }
-        const tx = this.store.beginTransaction(), parent = dirname(p), parentNode = await this.findINode(tx, parent), parentListing = await this.getDirListing(tx, parentNode, parent), fileName = basename(p);
-        if (!parentListing[fileName]) {
-            throw ApiError.With('ENOENT', p, 'removeEntry');
-        }
-        const fileIno = parentListing[fileName];
-        // Get file inode.
-        const fileNode = await this.getINode(tx, fileIno, p);
-        if (!fileNode.toStats().hasAccess(W_OK, cred)) {
-            throw ApiError.With('EACCES', p, 'removeEntry');
-        }
-        // Remove from directory listing of parent.
-        delete parentListing[fileName];
-        if (!isDir && fileNode.toStats().isDirectory()) {
-            throw ApiError.With('EISDIR', p, 'removeEntry');
-        }
-        if (isDir && !fileNode.toStats().isDirectory()) {
-            throw ApiError.With('ENOTDIR', p, 'removeEntry');
-        }
-        try {
-            await tx.put(parentNode.ino, encodeDirListing(parentListing), true);
-            if (--fileNode.nlink < 1) {
-                // remove file
-                await tx.remove(fileNode.ino);
-                await tx.remove(fileIno);
-            }
-        }
-        catch (e) {
-            await tx.abort();
-            throw e;
-        }
-        // Success.
-        await tx.commit();
-    }
-}

package/dist/backends/InMemory.js

@@ -1,49 +0,0 @@
-import { SimpleSyncTransaction, SyncStoreFS } from './SyncStore.js';
-/**
- * A simple in-memory store
- */
-export class InMemoryStore {
-    constructor(name = 'tmp') {
-        this.name = name;
-        this.store = new Map();
-    }
-    clear() {
-        this.store.clear();
-    }
-    beginTransaction() {
-        return new SimpleSyncTransaction(this);
-    }
-    get(key) {
-        return this.store.get(key);
-    }
-    put(key, data, overwrite) {
-        if (!overwrite && this.store.has(key)) {
-            return false;
-        }
-        this.store.set(key, data);
-        return true;
-    }
-    remove(key) {
-        this.store.delete(key);
-    }
-}
-/**
- * A simple in-memory file system backed by an InMemoryStore.
- * Files are not persisted across page loads.
- */
-export const InMemory = {
-    name: 'InMemory',
-    isAvailable() {
-        return true;
-    },
-    options: {
-        name: {
-            type: 'string',
-            required: false,
-            description: 'The name of the store',
-        },
-    },
-    create({ name }) {
-        return new SyncStoreFS({ store: new InMemoryStore(name) });
-    },
-};