@zenfs/core 0.1.0 → 0.2.0

package/dist/backends/SyncStore.js

@@ -1,11 +1,12 @@
 import { dirname, basename, join, resolve, sep } from '../emulation/path.js';
 import { ApiError, ErrorCode } from '../ApiError.js';
 import { W_OK, R_OK } from '../emulation/constants.js';
-import { FileFlag, PreloadFile } from '../file.js';
-import { SynchronousFileSystem } from '../filesystem.js';
-import Inode from '../inode.js';
+import { PreloadFile } from '../file.js';
+import { SyncFileSystem } from '../filesystem.js';
+import { randomIno, Inode } from '../inode.js';
 import { FileType } from '../stats.js';
-import { decode, encode, randomUUID, ROOT_NODE_ID } from '../utils.js';
+import { decodeDirListing, encode, encodeDirListing } from '../utils.js';
+import { rootIno } from '../inode.js';
 /**
  * A simple RW transaction for simple synchronous key-value stores.
  */
@@ -16,24 +17,24 @@ export class SimpleSyncRWTransaction {
          * Stores data in the keys we modify prior to modifying them.
          * Allows us to roll back commits.
          */
-        this.originalData = {};
+        this.originalData = new Map();
         /**
          * List of keys modified in this transaction, if any.
          */
-        this.modifiedKeys = [];
+        this.modifiedKeys = new Set();
     }
-    get(key) {
-        const val = this.store.get(key);
-        this.stashOldValue(key, val);
+    get(ino) {
+        const val = this.store.get(ino);
+        this.stashOldValue(ino, val);
         return val;
     }
-    put(key, data, overwrite) {
-        this.markModified(key);
-        return this.store.put(key, data, overwrite);
+    put(ino, data, overwrite) {
+        this.markModified(ino);
+        return this.store.put(ino, data, overwrite);
     }
-    del(key) {
-        this.markModified(key);
-        this.store.del(key);
+    remove(ino) {
+        this.markModified(ino);
+        this.store.remove(ino);
     }
     commit() {
         /* NOP */
@@ -41,10 +42,10 @@ export class SimpleSyncRWTransaction {
     abort() {
         // Rollback old values.
         for (const key of this.modifiedKeys) {
-            const value = this.originalData[key];
+            const value = this.originalData.get(key);
             if (!value) {
                 // Key didn't exist.
-                this.store.del(key);
+                this.store.remove(key);
             }
             else {
                 // Key existed. Store old value.
@@ -52,44 +53,45 @@ export class SimpleSyncRWTransaction {
             }
         }
     }
-    _has(key) {
-        return Object.prototype.hasOwnProperty.call(this.originalData, key);
-    }
     /**
      * Stashes given key value pair into `originalData` if it doesn't already
      * exist. Allows us to stash values the program is requesting anyway to
      * prevent needless `get` requests if the program modifies the data later
      * on during the transaction.
      */
-    stashOldValue(key, value) {
+    stashOldValue(ino, value) {
         // Keep only the earliest value in the transaction.
-        if (!this._has(key)) {
-            this.originalData[key] = value;
+        if (!this.originalData.has(ino)) {
+            this.originalData.set(ino, value);
         }
     }
     /**
      * Marks the given key as modified, and stashes its value if it has not been
      * stashed already.
      */
-    markModified(key) {
-        if (this.modifiedKeys.indexOf(key) === -1) {
-            this.modifiedKeys.push(key);
-            if (!this._has(key)) {
-                this.originalData[key] = this.store.get(key);
-            }
+    markModified(ino) {
+        this.modifiedKeys.add(ino);
+        if (!this.originalData.has(ino)) {
+            this.originalData.set(ino, this.store.get(ino));
         }
     }
 }
-export class SyncKeyValueFile extends PreloadFile {
+export class SyncStoreFile extends PreloadFile {
     constructor(_fs, _path, _flag, _stat, contents) {
         super(_fs, _path, _flag, _stat, contents);
     }
+    async sync() {
+        this.syncSync();
+    }
     syncSync() {
         if (this.isDirty()) {
-            this._fs._syncSync(this.getPath(), this.getBuffer(), this.getStats());
+            this.fs.syncSync(this.path, this._buffer, this.stats);
             this.resetDirty();
         }
     }
+    async close() {
+        this.closeSync();
+    }
     closeSync() {
         this.syncSync();
     }
@@ -103,30 +105,22 @@ export class SyncKeyValueFile extends PreloadFile {
  * @todo Introduce Node ID caching.
  * @todo Check modes.
  */
-export class SyncKeyValueFileSystem extends SynchronousFileSystem {
-    static isAvailable() {
-        return true;
-    }
+export class SyncStoreFileSystem extends SyncFileSystem {
     constructor(options) {
         super();
         this.store = options.store;
         // INVARIANT: Ensure that the root exists.
         this.makeRootDirectory();
     }
-    getName() {
-        return this.store.name();
-    }
-    isReadOnly() {
-        return false;
-    }
-    supportsSymlinks() {
-        return false;
-    }
-    supportsProps() {
-        return true;
-    }
-    supportsSynch() {
-        return true;
+    get metadata() {
+        return {
+            name: this.store.name,
+            readonly: false,
+            supportsProperties: true,
+            synchronous: true,
+            freeSpace: 0,
+            totalSpace: 0,
+        };
     }
     /**
      * Delete all contents stored in the file system.
@@ -136,29 +130,23 @@ export class SyncKeyValueFileSystem extends SynchronousFileSystem {
         // INVARIANT: Root always exists.
         this.makeRootDirectory();
     }
-    accessSync(p, mode, cred) {
-        const tx = this.store.beginTransaction('readonly'), node = this.findINode(tx, p);
-        if (!node.toStats().hasAccess(mode, cred)) {
-            throw ApiError.EACCES(p);
-        }
-    }
     renameSync(oldPath, newPath, cred) {
         const tx = this.store.beginTransaction('readwrite'), oldParent = dirname(oldPath), oldName = basename(oldPath), newParent = dirname(newPath), newName = basename(newPath), 
         // Remove oldPath from parent's directory listing.
-        oldDirNode = this.findINode(tx, oldParent), oldDirList = this.getDirListing(tx, oldParent, oldDirNode);
+        oldDirNode = this.findINode(tx, oldParent), oldDirList = this.getDirListing(tx, oldDirNode, oldParent);
         if (!oldDirNode.toStats().hasAccess(W_OK, cred)) {
             throw ApiError.EACCES(oldPath);
         }
         if (!oldDirList[oldName]) {
             throw ApiError.ENOENT(oldPath);
         }
-        const nodeId = oldDirList[oldName];
+        const ino = 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) {
+        if ((newParent + '/').indexOf(oldPath + '/') == 0) {
             throw new ApiError(ErrorCode.EBUSY, oldParent);
         }
         // Add newPath to parent's directory listing.
@@ -171,15 +159,15 @@ export class SyncKeyValueFileSystem extends SynchronousFileSystem {
         }
         else {
             newDirNode = this.findINode(tx, newParent);
-            newDirList = this.getDirListing(tx, newParent, newDirNode);
+            newDirList = this.getDirListing(tx, newDirNode, newParent);
         }
         if (newDirList[newName]) {
             // If it's a file, delete it.
-            const newNameNode = this.getINode(tx, newPath, newDirList[newName]);
-            if (newNameNode.isFile()) {
+            const newNameNode = this.getINode(tx, newDirList[newName], newPath);
+            if (newNameNode.toStats().isFile()) {
                 try {
-                    tx.del(newNameNode.id);
-                    tx.del(newDirList[newName]);
+                    tx.remove(newNameNode.ino);
+                    tx.remove(newDirList[newName]);
                 }
                 catch (e) {
                     tx.abort();
@@ -191,11 +179,11 @@ export class SyncKeyValueFileSystem extends SynchronousFileSystem {
                 throw ApiError.EPERM(newPath);
             }
         }
-        newDirList[newName] = nodeId;
+        newDirList[newName] = ino;
         // Commit the two changed directory listings.
         try {
-            tx.put(oldDirNode.id, encode(JSON.stringify(oldDirList)), true);
-            tx.put(newDirNode.id, encode(JSON.stringify(newDirList)), true);
+            tx.put(oldDirNode.ino, encodeDirListing(oldDirList), true);
+            tx.put(newDirNode.ino, encodeDirListing(newDirList), true);
         }
         catch (e) {
             tx.abort();
@@ -212,19 +200,18 @@ export class SyncKeyValueFileSystem extends SynchronousFileSystem {
         return stats;
     }
     createFileSync(p, flag, mode, cred) {
-        const tx = this.store.beginTransaction('readwrite'), data = new Uint8Array(0), newFile = this.commitNewFile(tx, p, FileType.FILE, mode, cred, data);
-        // Open the file.
-        return new SyncKeyValueFile(this, p, flag, newFile.toStats(), data);
+        this.commitNewFile(p, FileType.FILE, mode, cred);
+        return this.openFileSync(p, flag, cred);
     }
     openFileSync(p, flag, cred) {
-        const tx = this.store.beginTransaction('readonly'), node = this.findINode(tx, p), data = tx.get(node.id);
-        if (!node.toStats().hasAccess(flag.getMode(), cred)) {
+        const tx = this.store.beginTransaction('readonly'), node = this.findINode(tx, p), data = tx.get(node.ino);
+        if (!node.toStats().hasAccess(flag.mode, cred)) {
             throw ApiError.EACCES(p);
         }
-        if (data === undefined) {
+        if (data === null) {
             throw ApiError.ENOENT(p);
         }
-        return new SyncKeyValueFile(this, p, flag, node.toStats(), data);
+        return new SyncStoreFile(this, p, flag, node.toStats(), data);
     }
     unlinkSync(p, cred) {
         this.removeEntry(p, false, cred);
@@ -239,8 +226,7 @@ export class SyncKeyValueFileSystem extends SynchronousFileSystem {
         }
     }
     mkdirSync(p, mode, cred) {
-        const tx = this.store.beginTransaction('readwrite'), data = encode('{}');
-        this.commitNewFile(tx, p, FileType.DIRECTORY, mode, cred, data);
+        this.commitNewFile(p, FileType.DIRECTORY, mode, cred, encode('{}'));
     }
     readdirSync(p, cred) {
         const tx = this.store.beginTransaction('readonly');
@@ -248,28 +234,20 @@ export class SyncKeyValueFileSystem extends SynchronousFileSystem {
         if (!node.toStats().hasAccess(R_OK, cred)) {
             throw ApiError.EACCES(p);
         }
-        return Object.keys(this.getDirListing(tx, p, node));
-    }
-    chmodSync(p, mode, cred) {
-        const fd = this.openFileSync(p, FileFlag.getFileFlag('r+'), cred);
-        fd.chmodSync(mode);
+        return Object.keys(this.getDirListing(tx, node, p));
     }
-    chownSync(p, new_uid, new_gid, cred) {
-        const fd = this.openFileSync(p, FileFlag.getFileFlag('r+'), cred);
-        fd.chownSync(new_uid, new_gid);
-    }
-    _syncSync(p, data, stats) {
+    syncSync(p, data, stats) {
         // @todo Ensure mtime updates properly, and use that to determine if a data
         //       update is required.
         const tx = this.store.beginTransaction('readwrite'), 
         // We use the _findInode helper because we actually need the INode id.
-        fileInodeId = this._findINode(tx, dirname(p), basename(p)), fileInode = this.getINode(tx, p, fileInodeId), inodeChanged = fileInode.update(stats);
+        fileInodeId = this._findINode(tx, dirname(p), basename(p)), fileInode = this.getINode(tx, fileInodeId, p), inodeChanged = fileInode.update(stats);
         try {
             // Sync data.
-            tx.put(fileInode.id, data, true);
+            tx.put(fileInode.ino, data, true);
             // Sync metadata.
             if (inodeChanged) {
-                tx.put(fileInodeId, fileInode.serialize(), true);
+                tx.put(fileInodeId, fileInode.data, true);
             }
         }
         catch (e) {
@@ -278,22 +256,47 @@ export class SyncKeyValueFileSystem extends SynchronousFileSystem {
         }
         tx.commit();
     }
+    linkSync(existing, newpath, cred) {
+        const tx = this.store.beginTransaction('readwrite'), existingDir = dirname(existing), existingDirNode = this.findINode(tx, existingDir);
+        if (!existingDirNode.toStats().hasAccess(R_OK, cred)) {
+            throw ApiError.EACCES(existingDir);
+        }
+        const newDir = dirname(newpath), newDirNode = this.findINode(tx, newDir), newListing = this.getDirListing(tx, newDirNode, newDir);
+        if (!newDirNode.toStats().hasAccess(W_OK, cred)) {
+            throw ApiError.EACCES(newDir);
+        }
+        const ino = this._findINode(tx, existingDir, basename(existing));
+        const node = this.getINode(tx, ino, existing);
+        if (!node.toStats().hasAccess(W_OK, cred)) {
+            throw ApiError.EACCES(newpath);
+        }
+        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.
      */
     makeRootDirectory() {
         const tx = this.store.beginTransaction('readwrite');
-        if (tx.get(ROOT_NODE_ID) === undefined) {
-            // Create new inode.
-            const currTime = new Date().getTime(), 
-            // Mode 0666, owned by root:root
-            dirInode = new Inode(randomUUID(), 4096, 511 | FileType.DIRECTORY, currTime, currTime, currTime, 0, 0);
-            // If the root doesn't exist, the first random ID shouldn't exist,
-            // either.
-            tx.put(dirInode.id, encode('{}'), false);
-            tx.put(ROOT_NODE_ID, dirInode.serialize(), false);
-            tx.commit();
-        }
+        if (tx.get(rootIno)) {
+            return;
+        }
+        // Create new inode, mode 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.
+        tx.put(inode.ino, encode('{}'), false);
+        tx.put(rootIno, inode.data, false);
+        tx.commit();
     }
     /**
      * Helper function for findINode.
@@ -308,30 +311,24 @@ export class SyncKeyValueFileSystem extends SynchronousFileSystem {
             throw new ApiError(ErrorCode.EIO, 'Infinite loop detected while finding inode', currentPath);
         }
         visited.add(currentPath);
-        const readDirectory = (inode) => {
-            // Get the root's directory listing.
-            const dirList = this.getDirListing(tx, parent, inode);
-            // Get the file's ID.
-            if (dirList[filename]) {
-                return dirList[filename];
-            }
-            else {
+        if (parent != '/') {
+            const ino = this._findINode(tx, dirname(parent), basename(parent), visited);
+            const dir = this.getDirListing(tx, this.getINode(tx, ino, parent + sep + filename), parent);
+            if (!(filename in dir)) {
                 throw ApiError.ENOENT(resolve(parent, filename));
             }
-        };
-        if (parent === '/') {
-            if (filename === '') {
-                // Return the root's ID.
-                return ROOT_NODE_ID;
-            }
-            else {
-                // Find the item in the root node.
-                return readDirectory(this.getINode(tx, parent, ROOT_NODE_ID));
-            }
+            return dir[filename];
         }
-        else {
-            return readDirectory(this.getINode(tx, parent + sep + filename, this._findINode(tx, dirname(parent), basename(parent), visited)));
+        if (filename != '') {
+            // Find the item in the root node.
+            const dir = this.getDirListing(tx, this.getINode(tx, rootIno, parent), parent);
+            if (!(filename in dir)) {
+                throw ApiError.ENOENT(resolve(parent, filename));
+            }
+            return dir[filename];
         }
+        // Return the root's ID.
+        return rootIno;
     }
     /**
      * Finds the Inode of the given path.
@@ -340,7 +337,8 @@ export class SyncKeyValueFileSystem extends SynchronousFileSystem {
      * @todo memoize/cache
      */
     findINode(tx, p) {
-        return this.getINode(tx, p, this._findINode(tx, dirname(p), basename(p)));
+        const ino = this._findINode(tx, dirname(p), basename(p));
+        return this.getINode(tx, ino, p);
     }
     /**
      * Given the ID of a node, retrieves the corresponding Inode.
@@ -348,26 +346,25 @@ export class SyncKeyValueFileSystem extends SynchronousFileSystem {
      * @param p The corresponding path to the file (used for error messages).
      * @param id The ID to look up.
      */
-    getINode(tx, p, id) {
-        const inode = tx.get(id);
-        if (inode === undefined) {
+    getINode(tx, id, p) {
+        const data = tx.get(id);
+        if (!data) {
             throw ApiError.ENOENT(p);
         }
-        return Inode.Deserialize(inode);
+        return new Inode(data.buffer);
     }
     /**
-     * Given the Inode of a directory, retrieves the corresponding directory
-     * listing.
+     * Given the Inode of a directory, retrieves the corresponding directory listing.
      */
-    getDirListing(tx, p, inode) {
-        if (!inode.isDirectory()) {
+    getDirListing(tx, inode, p) {
+        if (!inode.toStats().isDirectory()) {
             throw ApiError.ENOTDIR(p);
         }
-        const data = tx.get(inode.id);
-        if (data === undefined) {
+        const data = tx.get(inode.ino);
+        if (!data) {
             throw ApiError.ENOENT(p);
         }
-        return JSON.parse(decode(data));
+        return decodeDirListing(data);
     }
     /**
      * Creates a new node under a random ID. Retries 5 times before giving up in
@@ -376,12 +373,12 @@ export class SyncKeyValueFileSystem extends SynchronousFileSystem {
      */
     addNewNode(tx, data) {
         const retries = 0;
-        let currId;
+        let ino;
         while (retries < 5) {
             try {
-                currId = randomUUID();
-                tx.put(currId, data, false);
-                return currId;
+                ino = randomIno();
+                tx.put(ino, data, false);
+                return ino;
             }
             catch (e) {
                 // Ignore and reroll.
@@ -390,8 +387,7 @@ export class SyncKeyValueFileSystem extends SynchronousFileSystem {
         throw new ApiError(ErrorCode.EIO, 'Unable to commit data to key-value store.');
     }
     /**
-     * Commits a new file (well, a FILE or a DIRECTORY) to the file system with
-     * the given mode.
+     * 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.
@@ -399,15 +395,16 @@ export class SyncKeyValueFileSystem extends SynchronousFileSystem {
      * @param data The data to store at the file's data node.
      * @return The Inode for the new file.
      */
-    commitNewFile(tx, p, type, mode, cred, data) {
-        const parentDir = dirname(p), fname = basename(p), parentNode = this.findINode(tx, parentDir), dirListing = this.getDirListing(tx, parentDir, parentNode), currTime = new Date().getTime();
+    commitNewFile(p, type, mode, cred, data = new Uint8Array()) {
+        const tx = this.store.beginTransaction('readwrite'), parentDir = dirname(p), fname = basename(p), parentNode = this.findINode(tx, parentDir), dirListing = this.getDirListing(tx, parentNode, parentDir);
         //Check that the creater has correct access
-        if (!parentNode.toStats().hasAccess(0b0100 /* Write */, cred)) {
+        if (!parentNode.toStats().hasAccess(W_OK, cred)) {
             throw ApiError.EACCES(p);
         }
-        // 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 == '/'.
+        /* 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.EEXIST(p);
         }
@@ -415,16 +412,17 @@ export class SyncKeyValueFileSystem extends SynchronousFileSystem {
         if (dirListing[fname]) {
             throw ApiError.EEXIST(p);
         }
-        let fileNode;
+        const fileNode = new Inode();
         try {
             // Commit data.
-            const dataId = this.addNewNode(tx, data);
-            fileNode = new Inode(dataId, data.length, mode | type, currTime, currTime, currTime, cred.uid, cred.gid);
-            // Commit file node.
-            const fileNodeId = this.addNewNode(tx, fileNode.serialize());
+            fileNode.ino = this.addNewNode(tx, data);
+            fileNode.size = data.length;
+            fileNode.mode = mode | type;
+            fileNode.uid = cred.uid;
+            fileNode.gid = cred.gid;
             // Update and commit parent directory listing.
-            dirListing[fname] = fileNodeId;
-            tx.put(parentNode.id, encode(JSON.stringify(dirListing)), true);
+            dirListing[fname] = this.addNewNode(tx, fileNode.data);
+            tx.put(parentNode.ino, encodeDirListing(dirListing), true);
         }
         catch (e) {
             tx.abort();
@@ -440,31 +438,31 @@ export class SyncKeyValueFileSystem extends SynchronousFileSystem {
      * @todo Update mtime.
      */
     removeEntry(p, isDir, cred) {
-        const tx = this.store.beginTransaction('readwrite'), parent = dirname(p), parentNode = this.findINode(tx, parent), parentListing = this.getDirListing(tx, parent, parentNode), fileName = basename(p);
-        if (!parentListing[fileName]) {
+        const tx = this.store.beginTransaction('readwrite'), parent = dirname(p), parentNode = this.findINode(tx, parent), parentListing = this.getDirListing(tx, parentNode, parent), fileName = basename(p), fileIno = parentListing[fileName];
+        if (!fileIno) {
             throw ApiError.ENOENT(p);
         }
-        const fileNodeId = parentListing[fileName];
         // Get file inode.
-        const fileNode = this.getINode(tx, p, fileNodeId);
+        const fileNode = this.getINode(tx, fileIno, p);
         if (!fileNode.toStats().hasAccess(W_OK, cred)) {
             throw ApiError.EACCES(p);
         }
         // Remove from directory listing of parent.
         delete parentListing[fileName];
-        if (!isDir && fileNode.isDirectory()) {
+        if (!isDir && fileNode.toStats().isDirectory()) {
             throw ApiError.EISDIR(p);
         }
-        else if (isDir && !fileNode.isDirectory()) {
+        if (isDir && !fileNode.toStats().isDirectory()) {
             throw ApiError.ENOTDIR(p);
         }
         try {
-            // Delete data.
-            tx.del(fileNode.id);
-            // Delete node.
-            tx.del(fileNodeId);
             // Update directory listing.
-            tx.put(parentNode.id, encode(JSON.stringify(parentListing)), true);
+            tx.put(parentNode.ino, encodeDirListing(parentListing), true);
+            if (--fileNode.nlink < 1) {
+                // remove file
+                tx.remove(fileNode.ino);
+                tx.remove(fileIno);
+            }
         }
         catch (e) {
             tx.abort();