@zenfs/core 0.0.12 → 0.2.0

package/dist/backends/AsyncStore.js

@@ -1,142 +1,80 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 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, FileFlag } from '../file.js';
-import { BaseFileSystem } from '../filesystem.js';
-import Inode from '../inode.js';
+import { PreloadFile } from '../file.js';
+import { AsyncFileSystem } from '../filesystem.js';
+import { randomIno, Inode } from '../inode.js';
 import { FileType } from '../stats.js';
-import { ROOT_NODE_ID, randomUUID, encode } from '../utils.js';
-class LRUNode {
-    constructor(key, value) {
-        this.key = key;
-        this.value = value;
-        this.prev = null;
-        this.next = null;
-    }
-}
-// Adapted from https://chrisrng.svbtle.com/lru-cache-in-javascript
+import { encode, decodeDirListing, encodeDirListing } from '../utils.js';
+import { rootIno } from '../inode.js';
+/**
+ * Last Recently Used cache
+ */
 class LRUCache {
     constructor(limit) {
         this.limit = limit;
-        this.size = 0;
-        this.map = {};
-        this.head = null;
-        this.tail = null;
+        this.cache = [];
     }
-    /**
-     * Change or add a new value in the cache
-     * We overwrite the entry if it already exists
-     */
     set(key, value) {
-        const node = new LRUNode(key, value);
-        if (this.map[key]) {
-            this.map[key].value = node.value;
-            this.remove(node.key);
+        const existingIndex = this.cache.findIndex(node => node.key === key);
+        if (existingIndex != -1) {
+            this.cache.splice(existingIndex, 1);
         }
-        else {
-            if (this.size >= this.limit) {
-                delete this.map[this.tail.key];
-                this.size--;
-                this.tail = this.tail.prev;
-                this.tail.next = null;
-            }
+        else if (this.cache.length >= this.limit) {
+            this.cache.shift();
         }
-        this.setHead(node);
+        this.cache.push({ key, value });
     }
-    /* Retrieve a single entry from the cache */
     get(key) {
-        if (this.map[key]) {
-            const value = this.map[key].value;
-            const node = new LRUNode(key, value);
-            this.remove(key);
-            this.setHead(node);
-            return value;
-        }
-        else {
-            return null;
-        }
-    }
-    /* Remove a single entry from the cache */
-    remove(key) {
-        const node = this.map[key];
+        const node = this.cache.find(n => n.key === key);
         if (!node) {
             return;
         }
-        if (node.prev !== null) {
-            node.prev.next = node.next;
-        }
-        else {
-            this.head = node.next;
-        }
-        if (node.next !== null) {
-            node.next.prev = node.prev;
-        }
-        else {
-            this.tail = node.prev;
-        }
-        delete this.map[key];
-        this.size--;
+        // Move the accessed item to the end of the cache (most recently used)
+        this.set(key, node.value);
+        return node.value;
     }
-    /* Resets the entire cache - Argument limit is optional to be reset */
-    removeAll() {
-        this.size = 0;
-        this.map = {};
-        this.head = null;
-        this.tail = null;
-    }
-    setHead(node) {
-        node.next = this.head;
-        node.prev = null;
-        if (this.head !== null) {
-            this.head.prev = node;
-        }
-        this.head = node;
-        if (this.tail === null) {
-            this.tail = node;
+    remove(key) {
+        const index = this.cache.findIndex(node => node.key === key);
+        if (index !== -1) {
+            this.cache.splice(index, 1);
         }
-        this.size++;
-        this.map[node.key] = node;
+    }
+    reset() {
+        this.cache = [];
     }
 }
-export class AsyncKeyValueFile extends PreloadFile {
+export class AsyncFile extends PreloadFile {
     constructor(_fs, _path, _flag, _stat, contents) {
         super(_fs, _path, _flag, _stat, contents);
     }
-    sync() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.isDirty()) {
-                return;
-            }
-            yield this._fs._sync(this.getPath(), this.getBuffer(), this.getStats());
-            this.resetDirty();
-        });
+    async sync() {
+        if (!this.isDirty()) {
+            return;
+        }
+        await this.fs.sync(this.path, this._buffer, this.stats);
+        this.resetDirty();
+    }
+    syncSync() {
+        throw new ApiError(ErrorCode.ENOTSUP);
+    }
+    async close() {
+        this.sync();
     }
-    close() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.sync();
-        });
+    closeSync() {
+        throw new ApiError(ErrorCode.ENOTSUP);
     }
 }
 /**
  * An "Asynchronous key-value file system". Stores data to/retrieves data from
  * an underlying asynchronous key-value store.
  */
-export class AsyncKeyValueFileSystem extends BaseFileSystem {
-    static isAvailable() {
-        return true;
+export class AsyncStoreFileSystem extends AsyncFileSystem {
+    ready() {
+        return this._ready;
     }
     constructor(cacheSize) {
         super();
-        this._cache = null;
         if (cacheSize > 0) {
             this._cache = new LRUCache(cacheSize);
         }
@@ -145,245 +83,212 @@ export class AsyncKeyValueFileSystem extends BaseFileSystem {
      * Initializes the file system. Typically called by subclasses' async
      * constructors.
      */
-    init(store) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.store = store;
-            // INVARIANT: Ensure that the root exists.
-            yield this.makeRootDirectory();
-        });
-    }
-    getName() {
-        return this.store.name();
-    }
-    isReadOnly() {
-        return false;
-    }
-    supportsSymlinks() {
-        return false;
-    }
-    supportsProps() {
-        return true;
-    }
-    supportsSynch() {
-        return false;
+    async init(store) {
+        this.store = store;
+        // INVARIANT: Ensure that the root exists.
+        await this.makeRootDirectory();
     }
     /**
      * Delete all contents stored in the file system.
      */
-    empty() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._cache) {
-                this._cache.removeAll();
-            }
-            yield this.store.clear();
-            // INVARIANT: Root always exists.
-            yield this.makeRootDirectory();
-        });
-    }
-    access(p, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const tx = this.store.beginTransaction('readonly');
-            const inode = yield this.findINode(tx, p);
-            if (!inode) {
-                throw ApiError.ENOENT(p);
-            }
-            if (!inode.toStats().hasAccess(mode, cred)) {
-                throw ApiError.EACCES(p);
-            }
-        });
+    async empty() {
+        if (this._cache) {
+            this._cache.reset();
+        }
+        await this.store.clear();
+        // INVARIANT: Root always exists.
+        await this.makeRootDirectory();
     }
     /**
      * @todo Make rename compatible with the cache.
      */
-    rename(oldPath, newPath, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const c = this._cache;
-            if (this._cache) {
-                // Clear and disable cache during renaming process.
-                this._cache = null;
-                c.removeAll();
+    async rename(oldPath, newPath, cred) {
+        const c = this._cache;
+        if (this._cache) {
+            // Clear and disable cache during renaming process.
+            this._cache = null;
+            c.reset();
+        }
+        try {
+            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 = await this.findINode(tx, oldParent), oldDirList = await 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];
+            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;
             }
-            try {
-                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 = yield this.findINode(tx, oldParent), oldDirList = yield this.getDirListing(tx, oldParent, oldDirNode);
-                if (!oldDirNode.toStats().hasAccess(W_OK, cred)) {
-                    throw ApiError.EACCES(oldPath);
-                }
-                if (!oldDirList[oldName]) {
-                    throw ApiError.ENOENT(oldPath);
-                }
-                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 = yield this.findINode(tx, newParent);
-                    newDirList = yield this.getDirListing(tx, newParent, newDirNode);
-                }
-                if (newDirList[newName]) {
-                    // If it's a file, delete it.
-                    const newNameNode = yield this.getINode(tx, newPath, newDirList[newName]);
-                    if (newNameNode.isFile()) {
-                        try {
-                            yield tx.del(newNameNode.id);
-                            yield tx.del(newDirList[newName]);
-                        }
-                        catch (e) {
-                            yield tx.abort();
-                            throw e;
-                        }
+            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]);
                     }
-                    else {
-                        // If it's a directory, throw a permissions error.
-                        throw ApiError.EPERM(newPath);
+                    catch (e) {
+                        await tx.abort();
+                        throw e;
                     }
                 }
-                newDirList[newName] = nodeId;
-                // Commit the two changed directory listings.
-                try {
-                    yield tx.put(oldDirNode.id, encode(JSON.stringify(oldDirList)), true);
-                    yield tx.put(newDirNode.id, encode(JSON.stringify(newDirList)), true);
-                }
-                catch (e) {
-                    yield tx.abort();
-                    throw e;
-                }
-                yield tx.commit();
-            }
-            finally {
-                if (c) {
-                    this._cache = c;
+                else {
+                    // If it's a directory, throw a permissions error.
+                    throw ApiError.EPERM(newPath);
                 }
             }
-        });
-    }
-    stat(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const tx = this.store.beginTransaction('readonly');
-            const inode = yield this.findINode(tx, p);
-            const stats = inode.toStats();
-            if (!stats.hasAccess(R_OK, cred)) {
-                throw ApiError.EACCES(p);
-            }
-            return stats;
-        });
-    }
-    createFile(p, flag, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const tx = this.store.beginTransaction('readwrite'), data = new Uint8Array(0), newFile = yield this.commitNewFile(tx, p, FileType.FILE, mode, cred, data);
-            // Open the file.
-            return new AsyncKeyValueFile(this, p, flag, newFile.toStats(), data);
-        });
-    }
-    openFile(p, flag, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const tx = this.store.beginTransaction('readonly'), node = yield this.findINode(tx, p), data = yield tx.get(node.id);
-            if (!node.toStats().hasAccess(flag.getMode(), cred)) {
-                throw ApiError.EACCES(p);
-            }
-            if (data === undefined) {
-                throw ApiError.ENOENT(p);
-            }
-            return new AsyncKeyValueFile(this, p, flag, node.toStats(), data);
-        });
-    }
-    unlink(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.removeEntry(p, false, cred);
-        });
-    }
-    rmdir(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Check first if directory is empty.
-            const list = yield this.readdir(p, cred);
-            if (list.length > 0) {
-                throw ApiError.ENOTEMPTY(p);
-            }
-            yield this.removeEntry(p, true, cred);
-        });
-    }
-    mkdir(p, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const tx = this.store.beginTransaction('readwrite'), data = encode('{}');
-            yield this.commitNewFile(tx, p, FileType.DIRECTORY, mode, cred, data);
-        });
-    }
-    readdir(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const tx = this.store.beginTransaction('readonly');
-            const node = yield this.findINode(tx, p);
-            if (!node.toStats().hasAccess(R_OK, cred)) {
-                throw ApiError.EACCES(p);
-            }
-            return Object.keys(yield this.getDirListing(tx, p, node));
-        });
-    }
-    chmod(p, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fd = yield this.openFile(p, FileFlag.getFileFlag('r+'), cred);
-            yield fd.chmod(mode);
-        });
-    }
-    chown(p, new_uid, new_gid, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fd = yield this.openFile(p, FileFlag.getFileFlag('r+'), cred);
-            yield fd.chown(new_uid, new_gid);
-        });
-    }
-    _sync(p, data, stats) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // @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 = yield this._findINode(tx, dirname(p), basename(p)), fileInode = yield this.getINode(tx, p, fileInodeId), inodeChanged = fileInode.update(stats);
+            newDirList[newName] = nodeId;
+            // Commit the two changed directory listings.
             try {
-                // Sync data.
-                yield tx.put(fileInode.id, data, true);
-                // Sync metadata.
-                if (inodeChanged) {
-                    yield tx.put(fileInodeId, fileInode.serialize(), true);
-                }
+                await tx.put(oldDirNode.ino, encodeDirListing(oldDirList), true);
+                await tx.put(newDirNode.ino, encodeDirListing(newDirList), true);
             }
             catch (e) {
-                yield tx.abort();
+                await tx.abort();
                 throw e;
             }
-            yield tx.commit();
-        });
+            await tx.commit();
+        }
+        finally {
+            if (c) {
+                this._cache = c;
+            }
+        }
+    }
+    async stat(p, cred) {
+        const tx = this.store.beginTransaction('readonly');
+        const inode = await this.findINode(tx, p);
+        if (!inode) {
+            throw ApiError.ENOENT(p);
+        }
+        const stats = inode.toStats();
+        if (!stats.hasAccess(R_OK, cred)) {
+            throw ApiError.EACCES(p);
+        }
+        return stats;
+    }
+    async createFile(p, flag, mode, cred) {
+        const tx = this.store.beginTransaction('readwrite'), data = new Uint8Array(0), newFile = await this.commitNewFile(tx, p, FileType.FILE, mode, cred, data);
+        // Open the file.
+        return new AsyncFile(this, p, flag, newFile.toStats(), data);
+    }
+    async openFile(p, flag, cred) {
+        const tx = this.store.beginTransaction('readonly'), node = await this.findINode(tx, p), data = await tx.get(node.ino);
+        if (!node.toStats().hasAccess(flag.mode, cred)) {
+            throw ApiError.EACCES(p);
+        }
+        if (!data) {
+            throw ApiError.ENOENT(p);
+        }
+        return new AsyncFile(this, p, flag, node.toStats(), data);
+    }
+    async unlink(p, cred) {
+        return this.removeEntry(p, false, cred);
+    }
+    async rmdir(p, cred) {
+        // Check first if directory is empty.
+        const list = await this.readdir(p, cred);
+        if (list.length > 0) {
+            throw ApiError.ENOTEMPTY(p);
+        }
+        await this.removeEntry(p, true, cred);
+    }
+    async mkdir(p, mode, cred) {
+        const tx = this.store.beginTransaction('readwrite'), data = encode('{}');
+        await this.commitNewFile(tx, p, FileType.DIRECTORY, mode, cred, data);
+    }
+    async readdir(p, cred) {
+        const tx = this.store.beginTransaction('readonly');
+        const node = await this.findINode(tx, p);
+        if (!node.toStats().hasAccess(R_OK, cred)) {
+            throw ApiError.EACCES(p);
+        }
+        return Object.keys(await this.getDirListing(tx, node, p));
     }
     /**
-     * Checks if the root directory exists. Creates it if it doesn't.
+     * 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.
      */
-    makeRootDirectory() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const tx = this.store.beginTransaction('readwrite');
-            if ((yield 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.
-                yield tx.put(dirInode.id, encode('{}'), false);
-                yield tx.put(ROOT_NODE_ID, dirInode.serialize(), false);
-                yield tx.commit();
+    async sync(p, data, stats) {
+        const tx = this.store.beginTransaction('readwrite'), 
+        // 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) {
+        const tx = this.store.beginTransaction('readwrite'), existingDir = dirname(existing), existingDirNode = await this.findINode(tx, existingDir);
+        if (!existingDirNode.toStats().hasAccess(R_OK, cred)) {
+            throw ApiError.EACCES(existingDir);
+        }
+        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.EACCES(newDir);
+        }
+        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.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.
+     */
+    async makeRootDirectory() {
+        const tx = this.store.beginTransaction('readwrite');
+        if ((await tx.get(rootIno)) === undefined) {
+            // Create new inode. o777, owned by root:root
+            const dirInode = new Inode();
+            dirInode.mode = 0o777 | FileType.DIRECTORY;
+            // If the root doesn't exist, the first random ID shouldn't exist,
+            // either.
+            await tx.put(dirInode.ino, encode('{}'), false);
+            await tx.put(rootIno, dirInode.data, false);
+            await tx.commit();
+        }
     }
     /**
      * Helper function for findINode.
@@ -391,48 +296,30 @@ export class AsyncKeyValueFileSystem extends BaseFileSystem {
      * @param filename The filename of the inode we are attempting to find, minus
      *   the parent.
      */
-    _findINode(tx, parent, filename, visited = new Set()) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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;
-                }
+    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, ROOT_NODE_ID);
-                    }
-                    return ROOT_NODE_ID;
-                }
-                else {
-                    // BASE CASE #2: Find the item in the root node.
-                    const inode = yield this.getINode(tx, parent, ROOT_NODE_ID);
-                    const dirList = yield this.getDirListing(tx, parent, inode);
-                    if (dirList[filename]) {
-                        const id = dirList[filename];
-                        if (this._cache) {
-                            this._cache.set(currentPath, id);
-                        }
-                        return id;
-                    }
-                    else {
-                        throw ApiError.ENOENT(resolve(parent, filename));
-                    }
+        }
+        if (parent === '/') {
+            if (filename === '') {
+                // BASE CASE #1: Return the root's ID.
+                if (this._cache) {
+                    this._cache.set(currentPath, rootIno);
                 }
+                return rootIno;
             }
             else {
-                // Get the parent directory's INode, and find the file in its directory
-                // listing.
-                const inode = yield this.findINode(tx, parent, visited);
-                const dirList = yield this.getDirListing(tx, parent, inode);
+                // 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) {
@@ -444,18 +331,32 @@ export class AsyncKeyValueFileSystem extends BaseFileSystem {
                     throw ApiError.ENOENT(resolve(parent, filename));
                 }
             }
-        });
+        }
+        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.ENOENT(resolve(parent, filename));
+            }
+        }
     }
     /**
      * Finds the Inode of the given path.
      * @param p The path to look up.
      * @todo memoize/cache
      */
-    findINode(tx, p, visited = new Set()) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const id = yield this._findINode(tx, dirname(p), basename(p), visited);
-            return this.getINode(tx, p, id);
-        });
+    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.
@@ -463,62 +364,56 @@ export class AsyncKeyValueFileSystem extends BaseFileSystem {
      * @param p The corresponding path to the file (used for error messages).
      * @param id The ID to look up.
      */
-    getINode(tx, p, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = yield tx.get(id);
-            if (!data) {
-                throw ApiError.ENOENT(p);
-            }
-            return Inode.Deserialize(data);
-        });
+    async getINode(tx, id, p) {
+        const data = await tx.get(id);
+        if (!data) {
+            throw ApiError.ENOENT(p);
+        }
+        return new Inode(data.buffer);
     }
     /**
      * Given the Inode of a directory, retrieves the corresponding directory
      * listing.
      */
-    getDirListing(tx, p, inode) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!inode.isDirectory()) {
-                throw ApiError.ENOTDIR(p);
-            }
-            const data = yield tx.get(inode.id);
-            try {
-                return JSON.parse(data.toString());
-            }
-            catch (e) {
-                // 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.ENOENT(p);
-            }
-        });
+    async getDirListing(tx, inode, p) {
+        if (!inode.toStats().isDirectory()) {
+            throw ApiError.ENOTDIR(p);
+        }
+        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.ENOENT(p);
+        }
+        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 GUID.
+     * the exceedingly unlikely chance that we try to reuse a random ino.
      */
-    addNewNode(tx, data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let retries = 0;
-            const reroll = () => __awaiter(this, void 0, void 0, function* () {
-                if (++retries === 5) {
-                    // Max retries hit. Return with an error.
-                    throw new ApiError(ErrorCode.EIO, 'Unable to commit data to key-value store.');
+    async addNewNode(tx, data) {
+        let retries = 0;
+        const reroll = async () => {
+            if (++retries === 5) {
+                // Max retries hit. Return with an error.
+                throw new ApiError(ErrorCode.EIO, 'Unable to commit data to key-value store.');
+            }
+            else {
+                // Try again.
+                const ino = randomIno();
+                const committed = await tx.put(ino, data, false);
+                if (!committed) {
+                    return reroll();
                 }
                 else {
-                    // Try again.
-                    const currId = randomUUID();
-                    const committed = yield tx.put(currId, data, false);
-                    if (!committed) {
-                        return reroll();
-                    }
-                    else {
-                        return currId;
-                    }
+                    return ino;
                 }
-            });
-            return reroll();
-        });
+            }
+        };
+        return reroll();
     }
     /**
      * Commits a new file (well, a FILE or a DIRECTORY) to the file system with
@@ -530,41 +425,41 @@ export class AsyncKeyValueFileSystem extends BaseFileSystem {
      * @param cred The UID/GID to create the file with
      * @param data The data to store at the file's data node.
      */
-    commitNewFile(tx, p, type, mode, cred, data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const parentDir = dirname(p), fname = basename(p), parentNode = yield this.findINode(tx, parentDir), dirListing = yield this.getDirListing(tx, parentDir, parentNode), currTime = new Date().getTime();
-            //Check that the creater has correct access
-            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 == '/'.
-            if (p === '/') {
-                throw ApiError.EEXIST(p);
-            }
-            // Check if file already exists.
-            if (dirListing[fname]) {
-                yield tx.abort();
-                throw ApiError.EEXIST(p);
-            }
-            try {
-                // Commit data.
-                const dataId = yield this.addNewNode(tx, data);
-                const fileNode = new Inode(dataId, data.length, mode | type, currTime, currTime, currTime, cred.uid, cred.gid);
-                // Commit file node.
-                const fileNodeId = yield this.addNewNode(tx, fileNode.serialize());
-                // Update and commit parent directory listing.
-                dirListing[fname] = fileNodeId;
-                yield tx.put(parentNode.id, encode(JSON.stringify(dirListing)), true);
-                yield tx.commit();
-                return fileNode;
-            }
-            catch (e) {
-                tx.abort();
-                throw e;
-            }
-        });
+    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.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 == '/'.
+        if (p === '/') {
+            throw ApiError.EEXIST(p);
+        }
+        // Check if file already exists.
+        if (dirListing[fname]) {
+            await tx.abort();
+            throw ApiError.EEXIST(p);
+        }
+        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.
@@ -578,43 +473,41 @@ export class AsyncKeyValueFileSystem extends BaseFileSystem {
      * @param isDir Does the path belong to a directory, or a file?
      * @todo Update mtime.
      */
-    removeEntry(p, isDir, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._cache) {
-                this._cache.remove(p);
-            }
-            const tx = this.store.beginTransaction('readwrite'), parent = dirname(p), parentNode = yield this.findINode(tx, parent), parentListing = yield this.getDirListing(tx, parent, parentNode), fileName = basename(p);
-            if (!parentListing[fileName]) {
-                throw ApiError.ENOENT(p);
-            }
-            const fileNodeId = parentListing[fileName];
-            // Get file inode.
-            const fileNode = yield this.getINode(tx, p, fileNodeId);
-            if (!fileNode.toStats().hasAccess(W_OK, cred)) {
-                throw ApiError.EACCES(p);
-            }
-            // Remove from directory listing of parent.
-            delete parentListing[fileName];
-            if (!isDir && fileNode.isDirectory()) {
-                throw ApiError.EISDIR(p);
-            }
-            else if (isDir && !fileNode.isDirectory()) {
-                throw ApiError.ENOTDIR(p);
-            }
-            try {
-                // Delete data.
-                yield tx.del(fileNode.id);
-                // Delete node.
-                yield tx.del(fileNodeId);
-                // Update directory listing.
-                yield tx.put(parentNode.id, encode(JSON.stringify(parentListing)), true);
-            }
-            catch (e) {
-                yield tx.abort();
-                throw e;
+    async removeEntry(p, isDir, cred) {
+        if (this._cache) {
+            this._cache.remove(p);
+        }
+        const tx = this.store.beginTransaction('readwrite'), parent = dirname(p), parentNode = await this.findINode(tx, parent), parentListing = await this.getDirListing(tx, parentNode, parent), fileName = basename(p);
+        if (!parentListing[fileName]) {
+            throw ApiError.ENOENT(p);
+        }
+        const fileIno = parentListing[fileName];
+        // Get file inode.
+        const fileNode = await 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.toStats().isDirectory()) {
+            throw ApiError.EISDIR(p);
+        }
+        if (isDir && !fileNode.toStats().isDirectory()) {
+            throw ApiError.ENOTDIR(p);
+        }
+        try {
+            await tx.put(parentNode.ino, encodeDirListing(parentListing), true);
+            if (--fileNode.nlink < 1) {
+                // remove file
+                await tx.remove(fileNode.ino);
+                await tx.remove(fileIno);
             }
-            // Success.
-            yield tx.commit();
-        });
+        }
+        catch (e) {
+            await tx.abort();
+            throw e;
+        }
+        // Success.
+        await tx.commit();
     }
 }