From 47676be805c21b4dfbb3dae0cadd458e5a7d1275 Mon Sep 17 00:00:00 2001 From: Alan K Date: Thu, 5 Jul 2018 13:29:05 -0400 Subject: [PATCH] Initial commit - Partial re-write of some of the core filer implementation. - Makes use of ES6/ES7. - Core support for VFS and block storage. --- .gitignore | 5 + dist/filer.js | 1554 ++++++++++++++++++++++++++++++ package-lock.json | 459 +++++++++ package.json | 47 + rollup.config.js | 13 + src/common/buffer.js | 76 ++ src/common/constants.js | 28 + src/common/crypto.js | 26 + src/common/errors.js | 68 ++ src/common/index.js | 0 src/common/path.js | 204 ++++ src/common/platform.js | 24 + src/common/url.js | 117 +++ src/common/uuid.js | 63 ++ src/fs/file.js | 29 + src/fs/fs.js | 40 + src/fs/index.js | 3 + src/fs/node.js | 230 +++++ src/fs/providers/index.js | 7 + src/fs/providers/indexeddb-fs.js | 58 ++ src/fs/providers/mem-fs.js | 92 ++ src/fs/providers/root-fs.js | 96 ++ src/fs/stats.js | 97 ++ src/fs/super-node.js | 124 +++ src/index.js | 15 + src/sh/index.js | 12 + src/vfs/directory-entry.js | 20 + src/vfs/fdmap.js | 49 + src/vfs/index.js | 3 + src/vfs/node-cache.js | 65 ++ src/vfs/vfs-mount-table.js | 23 + src/vfs/vfs.js | 386 ++++++++ src/vfs/vfsmount.js | 53 + test/browser-test.html | 39 + test/compare.js | 19 + test/index.js | 22 + test/node-test.js | 29 + test/uuid-test.js | 15 + 38 files changed, 4210 insertions(+) create mode 100644 .gitignore create mode 100644 dist/filer.js create mode 100644 package-lock.json create mode 100644 package.json create mode 100644 rollup.config.js create mode 100644 src/common/buffer.js create mode 100644 src/common/constants.js create mode 100644 src/common/crypto.js create mode 100644 src/common/errors.js create mode 100644 src/common/index.js create mode 100644 src/common/path.js create mode 100644 src/common/platform.js create mode 100644 src/common/url.js create mode 100644 src/common/uuid.js create mode 100644 src/fs/file.js create mode 100644 src/fs/fs.js create mode 100644 src/fs/index.js create mode 100644 src/fs/node.js create mode 100644 src/fs/providers/index.js create mode 100644 src/fs/providers/indexeddb-fs.js create mode 100644 src/fs/providers/mem-fs.js create mode 100644 src/fs/providers/root-fs.js create mode 100644 src/fs/stats.js create mode 100644 src/fs/super-node.js create mode 100644 src/index.js create mode 100644 src/sh/index.js create mode 100644 src/vfs/directory-entry.js create mode 100644 src/vfs/fdmap.js create mode 100644 src/vfs/index.js create mode 100644 src/vfs/node-cache.js create mode 100644 src/vfs/vfs-mount-table.js create mode 100644 src/vfs/vfs.js create mode 100644 src/vfs/vfsmount.js create mode 100644 test/browser-test.html create mode 100644 test/compare.js create mode 100644 test/index.js create mode 100644 test/node-test.js create mode 100644 test/uuid-test.js diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..9878022 --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +node_modules +bower_components +.env +*~ +dist/filer-issue225.js diff --git a/dist/filer.js b/dist/filer.js new file mode 100644 index 0000000..b7a70c1 --- /dev/null +++ b/dist/filer.js @@ -0,0 +1,1554 @@ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : + typeof define === 'function' && define.amd ? define(factory) : + (global.Filer = factory()); +}(this, (function () { 'use strict'; + + class Platform + { + static supportsWebCrypto() + { + return ("undefined" !== typeof window && + "undefined" !== typeof window.crypto && + "function" === typeof window.crypto.getRandomValues); + } + + static supportsNodeCrypto() + { + if("undefined" !== typeof process) { + try { + require.resolve("crypto"); + return true; + } catch(e) { + } + } + + return false; + } + } + + class FilerError extends Error + { + constructor(message, path = null) + { + super(message); + + this.path = path; + } + } + + const errors = {}; + const errorDefinitions = + [ + { errno: -1, name: "UNKNOWN", text: "unknown error" }, + { errno: 0, name: "OK", text: "success" }, + { errno: 1, name: "EOF", text: "end of file" }, + + { errno: 9, name: "EBADF", text: "bad file descriptor" }, + { errno: 10, name: "EBUSY", text: "resource busy or locked" }, + + { errno: 18, name: "EINVAL", text: "invalid argument" }, + + { errno: 27, name: "ENOTDIR", text: "not a directory" }, + { errno: 28, name: "EISDIR", text: "illegal operation on directory" }, + + { errno: 34, name: "ENOENT", text: "no such file or directory" }, + + { errno: 47, name: "EEXIST", text: "file already exists" }, + + { errno: 50, name: "EPERM", text: "operation not permitted" }, + { errno: 51, name: "ELOOP", text: "too many symbolic links encountered" }, + + { errno: 53, name: "ENOTEMPTY", text: "directory not empty" }, + + { errno: 55, name: "EIO", text: "i/o error" }, + { errno: 56, name: "EROFS", text: "read-only file system" }, + { errno: 57, name: "ENODEV", text: "no such device" }, + + { errno: 58, name: "ECANCELED", text: "operation canceled" }, + + { errno: 1000, name: "ENOTSUPPORTED", text: "platform is not supported" }, + ]; + + for (let error of errorDefinitions) { + errors[error.errno] = errors[error.name] = class extends FilerError { + constructor(message, path) + { + super(message || error.text, path); + } + + get name() { return error.name } + + get code() { return error.name } + + get errno() { return error.errno } + + get message() { return this.message } + + get stack() { return (new Error(this.message)).stack } + + get toString() { + pathInfo = this.path ? (', \'' + this.path + '\'') : ''; + return `${this.name}: ${this.message}${pathInfo}`; + } + }; + } + + let Crypto; + if(Platform.supportsWebCrypto()) { + Crypto = class Crypto + { + static randomBytes(arrayBuffer) + { + return window.crypto.getRandomValues(arrayBuffer); + } + }; + } else if(Platform.supportsNodeCrypto()) { + let nodeCrypto = require("crypto"); + Crypto = class Crypto + { + static randomBytes(arrayBuffer) + { + return nodeCrypto.randomFillSync(arrayBuffer); + } + }; + } else { + throw new errors.ENOTSUPPORTED("crypto support is not available on this platform"); + } + + var Crypto$1 = Crypto; + + const BASE = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".split(''); + const BASE_MAP = {}; + + for (var z = 0; z < BASE.length; z += 1) { + var x = BASE[z]; + + if (BASE_MAP[x] !== undefined) throw new TypeError(`${x} is ambiguous`) + BASE_MAP[x] = z; + } + + function encode(source) { + if (source.length === 0) return '' + + var digits = [0]; + for (var i = 0; i < source.length; ++i) { + for (var j = 0, carry = source[i]; j < digits.length; ++j) { + carry += digits[j] << 8; + digits[j] = carry % BASE.length; + carry = (carry / BASE.length) | 0; + } + + while (carry > 0) { + digits.push(carry % BASE.length); + carry = (carry / BASE.length) | 0; + } + } + + var string = ""; + + for (var k = 0; source[k] === 0 && k < source.length - 1; ++k) + string += BASE[0]; + + for (var q = digits.length - 1; q >= 0; --q) + string += BASE[digits[q]]; + + return string + } + + class UUID { + static v4() + { + let buffer = new Uint8Array(16); + Crypto$1.randomBytes(buffer); + + buffer[6] &= 0b00001111; + buffer[6] |= 0b01000000; + + buffer[8] &= 0b00111111; + buffer[8] |= 0b10000000; + + return encode(buffer); + } + + static short() + { + return this.v4(); + } + } + + const __ = new WeakMap(); + + class FS + { + constructor(superNode, options) + { + let { proxy, revoke } = Proxy.revocable(this, {}); + + __.set(proxy, { + id: UUID.short(), // instance ID + revoke: revoke, + }); + + return proxy; + } + + get id() + { + return __.get(this).id; + } + + static async mount(dev, flags=[], options={}) + { + + } + + async umount() + { + __.get(this).revoke(); + } + + toString() + { + return this.id; + } + } + + class Buffer extends Uint8Array + { + constructor(arg, encodingOrOffset, length) + { + if (typeof arg === "number") { + if (typeof encodingOrOffset === "string") { + throw new TypeError(`The "string" argument must be of type string. Received type number`); + } + return allocUnsafe(arg); + } + return from(arg, encodingOrOffset, length); + } + + static get INSPECT_MAX_BYTES() { return 50 } + + static get K_MAX_LENGTH() { return 0x7fffffff } + + static isSupported() + { + try { + var arr = new Uint8Array(1); + arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}; + return arr.foo() === 42 + } catch (e) { + return false + } + } + + static from(value, encodingOrOffset, length) + { + if (typeof value === 'string') { + return fromString(value, encodingOrOffset) + } + + if (ArrayBuffer.isView(value)) { + return fromArrayLike(value) + } + + if (value == null) { + throw TypeError(`The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type ${typeof value}`); + } + + if (isInstance(value, ArrayBuffer) || + (value && isInstance(value.buffer, ArrayBuffer))) { + return fromArrayBuffer(value, encodingOrOffset, length) + } + + if (typeof value === 'number') { + throw new TypeError( + 'The "value" argument must not be of type number. Received type number' + ) + } + + var valueOf = value.valueOf && value.valueOf(); + if(valueOf != null && valueOf !== value) { + return Buffer.from(valueOf, encodingOrOffset, length); + } + + var b = fromObject(value); + if(b) { + return b; + } + + if(typeof Symbol !== "undefined" && Symbol.toPrimitive != null && + typeof value[Symbol.toPrimitive] === "function") { + return Buffer.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length); + } + + throw new TypeError(`The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type ${typeof value}`); + } + } + + const SUPER_NODE_ID = "0000000000000000000000"; + + const MODE_FILE = "FILE"; + const MODE_DIRECTORY = "DIRECTORY"; + const MODE_SYMBOLIC_LINK = "MODE_SYMBOLIC_LINK"; + const MODE_META = "META"; + + const ROOT_DIRECTORY_NAME = "/"; // basename(normalize(path)) + + const STDIN = 0; + const STDOUT = 1; + const STDERR = 2; + + const FIRST_DESCRIPTOR = 3; + + const N_VFS_DESCRIPTORS = 1024; + + const DATA_BLOCK_SEPARATOR = "#"; + + const MNT_READ_ONLY = "READ_ONLY"; + + const SYMLOOP_MAX = 10; + + const __$1 = new WeakMap(); + + class FDMap + { + constructor(size=N_VFS_DESCRIPTORS) + { + const map = new Array(size).fill(0); + + map[STDIN] = 1; + map[STDOUT] = 1; + map[STDERR] = 1; + + __$1.set(this, { + map: map, + next: FIRST_DESCRIPTOR, + }); + } + + claimUnused() + { + const map = __$1.get(this).map; + let next = __$1.get(this).next; + + for(let i = 0; i < map.length; ++ i) + { + let fd = (next+i) % map.length; + if(0 == map[fd]) { + this.claim(fd); + return fd; + } + } + + throw new Error(`unable to allocate file descriptor`); + } + + claim(fd) + { + __$1.get(this).map[fd] = 1; + } + + release(fd) + { + __$1.get(this).map[fd] = 0; + } + } + + const __$2 = new WeakMap(); + + class VFSMount + { + constructor({ parentVFSMount = null, flags = [], fs, rnode = null } = {}) + { + __$2.set(this, { + flags: flags, + fs: fs, + rnode: rnode, + + parent: parentVFSMount, + children: new Set(), + }); + + if(parentVFSMount) { + parentVFSMount.insertChild(this); + } + } + + get fs() { return __$2.get(this).fs } + + get rnode() { return __$2.get(this).rnode } + + get flags() { return __$2.get(this).flags } + + get parent() { return __$2.get(this).parent } + + get children() { return __$2.get(this).children } + + hasChildren() + { + const self = __$2.get(this); + + return this.children.size > 0; + } + + insertChild(vfsMount) + { + const self = __$2.get(this); + + self.children.add(vfsMount); + } + + removeChild(vfsMount) + { + const self = __$2.get(this); + + self.children.delete(vfsMount); + } + } + + const __$3 = new WeakMap(); + + class SuperNodeData + { + constructor({ dev, atime = Date.now(), mtime = Date.now(), ctime = Date.now(), rnode, version = UUID.short() } = {}) + { + __$3.set(this, { + dev: dev, + mode: MODE_META, + atime: atime || Date.now(), // access time (will mirror ctime after creation) + mtime: mtime || Date.now(), // creation/change time + ctime: ctime || Date.now(), // modified time + rnode: rnode, // root node + version: version, + }); + } + + get dev() { return __$3.get(this).dev } + + get mode() { return __$3.get(this).mode } + + get atime() { return __$3.get(this).atime } + set atime(value) { return __$3.get(this).atime = value } + + get mtime() { return __$3.get(this).mtime } + set mtime(value) { return __$3.get(this).mtime = value } + + get ctime() { return __$3.get(this).ctime } + set ctime(value) { return __$3.get(this).ctime = value } + + get version() { return __$3.get(this).version } + set version(value) { return __$3.get(this).version = value } + + get rnode() { return __$3.get(this).rnode } + set rnode(value) { return __$3.get(this).rnode = value } + + toJSON() + { + return { + dev: this.dev, + mode: this.mode, + atime: this.atime, + mtime: this.mtime, + ctime: this.ctime, + rnode: this.rnode, + version: this.version, + }; + } + } + + class SuperNode + { + constructor({ fs, data } = {}) + { + __$3.set(this, { + fs: fs, + id: SUPER_NODE_ID, + + data: new SuperNodeData(data), + }); + } + + get id() { return __$3.get(this).id } + + get fs() { return __$3.get(this).fs } + + get dev() { return __$3.get(this).data.dev } + + get mode() { return __$3.get(this).data.mode } + + get atime() { return __$3.get(this).data.atime } + set atime(value) { return __$3.get(this).data.atime = value } + + get mtime() { return __$3.get(this).data.mtime } + set mtime(value) { return __$3.get(this).data.mtime = value } + + get ctime() { return __$3.get(this).data.ctime } + set ctime(value) { return __$3.get(this).data.ctime = value } + + get rnode() { return __$3.get(this).data.rnode } + set rnode(value) { return __$3.get(this).data.rnode = value } + + get version() { return __$3.get(this).data.version } + set version(value) { return __$3.get(this).data.version = value } + + get data() { return __$3.get(this).data.toJSON() } + + static async read(fs) + { + let data = await fs.readNode(SUPER_NODE_ID); + return new SuperNode({ fs: fs, data: data }); + } + + async read() + { + let data = await this.fs.readNode(this.id); + __$3.get(this).data = new SuperNodeData(data); + } + + async write() + { + this.version = UUID.short(); + await fs.writeNode(this.id, this.data); + } + + toJSON() + { + return { + id: this.id, + data: __$3.get(this).data.toJSON(), + } + } + + toString() + { + return JSON.stringify(this.toJSON()); + } + } + + const __$4 = new WeakMap(); + + class NodeData + { + constructor({ mode, size = 0, atime, mtime, ctime, version = UUID.short(), flags, xattrs, nlinks, blksize, nblocks, blkid = UUID.short() }) + { + __$4.set(this, { + mode: mode, // node type (file, directory, etc) + size: size, + atime: atime || Date.now(), // access time (will mirror ctime after creation) + mtime: mtime || Date.now(), // creation/change time + ctime: ctime || Date.now(), // modified time + version: version || UUID.short(), + flags: flags || [], + xattrs: xattrs || {}, + nlinks: nlinks || 0, + blksize: blksize || 4096, + nblocks: nblocks || 0, + blkid: blkid, + }); + } + + get mode() { return __$4.get(this).mode } + + get atime() { return __$4.get(this).atime } + set atime(value) { return __$4.get(this).atime = value } + + get mtime() { return __$4.get(this).mtime } + set mtime(value) { return __$4.get(this).mtime = value } + + get ctime() { return __$4.get(this).ctime } + set ctime(value) { return __$4.get(this).ctime = value } + + get version() { return __$4.get(this).version } + set version(value) { return __$4.get(this).version = value } + + get flags() { return __$4.get(this).flags } + + get xattrs() { return __$4.get(this).xattrs } + + get nlinks() { return __$4.get(this).nlinks } + set nlinks(value) { return __$4.get(this).nlinks = value } + + get blksize() { return __$4.get(this).blksize } + + get nblocks() { return __$4.get(this).nblocks } + set nblocks(value) { return __$4.get(this).nblocks = value } + + get blkid() { return __$4.get(this).blkid } + set blkid(value) { return __$4.get(this).blkid = value } + + get size() { return __$4.get(this).size } + set size(value) { return __$4.get(this).size = value } + + toJSON() + { + return { + mode: this.mode, + size: this.size, + atime: this.atime, + mtime: this.mtime, + ctime: this.ctime, + nlinks: this.nlinks, + version: this.version, + blksize: this.blksize, + nblocks: this.nblocks, + blkid: this.blkid, + flags: this.flags, + xattrs: this.xattrs, + }; + } + } + + class Node + { + constructor({ fs, id = UUID.short(), data } = {}) + { + __$4.set(this, { + fs: fs, + id: id, + + data: new NodeData(data), + }); + } + + get fs() { return __$4.get(this).fs } + + get id() { return __$4.get(this).id } + + get size() { return __$4.get(this).data.size } + set size(value) { return __$4.get(this).data.size = value } + + get nlinks() { return __$4.get(this).data.nlinks } + set nlinks(value) { return __$4.get(this).data.nlinks = value } + + get version() { return __$4.get(this).data.version } + set version(value) { return __$4.get(this).data.version = value } + + get blksize() { return __$4.get(this).data.blksize } + + get nblocks() { return __$4.get(this).data.nblocks } + set nblocks(value) { return __$4.get(this).data.nblocks = value } + + get atime() { return __$4.get(this).data.atime } + set atime(value) { return __$4.get(this).data.atime = value } + + get mtime() { return __$4.get(this).data.mtime } + set mtime(value) { return __$4.get(this).data.mtime = value } + + get ctime() { return __$4.get(this).data.ctime } + set ctime(value) { return __$4.get(this).data.ctime = value } + + get mode() { return __$4.get(this).data.mode } + + get blkid() { return __$4.get(this).data.blkid } + set blkid(value) { return __$4.get(this).data.blkid = value } + + get flags() { return __$4.get(this).data.flags } + + get xattrs() { return __$4.get(this).data.xattrs } + + get data() { return __$4.get(this).data.toJSON() } + + isFile() + { + return MODE_FILE == this.mode; + } + + isDirectory() + { + return MODE_DIRECTORY == this.mode; + } + + isSymbolicLink() + { + return MODE_SYMBOLIC_LINK == this.mode; + } + + isSocket() + { + return MODE_SOCKET == this.mode; + } + + isFIFO() + { + return MODE_FIFO == this.mode; + } + + isCharacterDevice() + { + return MODE_CHARACTER_DEVICE == this.mode; + } + + isBlockDevice() + { + return MODE_BLOCK_DEVICE == this.mode; + } + + toString() + { + return JSON.stringify(this.toJSON()); + } + + static hash(fs, id) + { + return `${fs.id}${id}`; + } + + hash() + { + return Node.hash(this.fs, this.id); + } + + static async read(fs, id) + { + let data = await fs.readNode(id); + return new Node({ fs: fs, id: id, data: data }); + } + + async read() + { + let data = await this.fs.readNode(this.id); + __$4.get(this).data = new NodeData(data); + } + + async write() + { + this.version = UUID.short(); + return await this.fs.writeNode(this.id, this.data); + } + + async readData(block=0) + { + let data = await this.fs.readData(this.blkid, block); + + return data; + } + + async writeData(block=0, data) + { + this.nblocks = block + 1; + await this.fs.writeData(this.blkid, block, data); + } + + async validate() + { + + } + + toJSON() + { + return { + fs: this.fs.id, + id: this.id, + data: __$4.get(this).data.toJSON(), + } + } + + toString() + { + return JSON.stringify(this.toJSON()); + } + } + + const __$5 = new WeakMap(); + + /* + RootFS is a read-only file system containing exactly one + directory node. It is created automatically by the VFS + layer. Its only purpose is to allow the VFS to mount another + file system on top of its only node. + */ + + class RootFS extends FS + { + constructor(options={}) + { + super(options); + + let superNode = new SuperNode({ fs: this, data: { dev: UUID.short() } }); + + let rootNode = new Node({ fs: this, data: { mode: MODE_DIRECTORY, nlinks: 1 } }); + superNode.rnode = rootNode.id; + + let storage = new Map(); + storage.set(superNode.id, superNode.data); + storage.set(rootNode.id, rootNode.data); + + __$5.set(this, { + storage: storage, + }); + } + + static get type() + { + return "rootfs"; + } + + static async mount() + { + throw new errors.UNKNOWN("mount operation not available for rootfs"); + } + + async umount() + { + throw new errors.UNKNOWN("umount operation not available for rootfs"); + } + + async readNode(id) + { + let node = __$5.get(this).storage.get(id); + + if(!node) { + throw new errors.ENOENT(); + } + + return node; + } + + async writeNode(id, node) + { + throw new errors.EROFS(); + } + + async readData(id, block=0) + { + let data = __$5.get(this).storage.get(`${id}${DATA_BLOCK_SEPARATOR}${block}`); + + if(!data) { + throw new errors.EIO(); + } + + return data; + } + + async writeData(id, block, data) + { + throw new errors.EROFS(); + } + + async fsync() + { + + } + + async validate(id) + { + + } + } + + function normalizeArray(parts, allowAboveRoot) { + // if the path tries to go above the root, `up` ends up > 0 + var up = 0; + for (var i = parts.length - 1; i >= 0; i--) { + var last = parts[i]; + if (last === '.') { + parts.splice(i, 1); + } else if (last === '..') { + parts.splice(i, 1); + up++; + } else if (up) { + parts.splice(i, 1); + up--; + } + } + + // if the path is allowed to go above the root, restore leading ..s + if (allowAboveRoot) { + for (; up--; up) { + parts.unshift('..'); + } + } + + return parts; + } + + // Split a filename into [root, dir, basename, ext], unix version + // 'root' is just a slash, or nothing. + var splitPathRe = + /^(\/?)([\s\S]+\/(?!$)|\/)?((?:\.{1,2}$|[\s\S]+?)?(\.[^.\/]*)?)$/; + var splitPath = function(filename) { + var result = splitPathRe.exec(filename); + return [result[1] || '', result[2] || '', result[3] || '', result[4] || '']; + }; + + // path.normalize(path) + function normalize(path) { + var isAbsolute = path.charAt(0) === '/', + trailingSlash = path.substr(-1) === '/'; + + // Normalize the path + path = normalizeArray(path.split('/').filter(function(p) { + return !!p; + }), !isAbsolute).join('/'); + + if (!path && !isAbsolute) { + path = '.'; + } + /* + if (path && trailingSlash) { + path += '/'; + } + */ + + return (isAbsolute ? '/' : '') + path; + } + + function dirname(path) { + var result = splitPath(path), + root = result[0], + dir = result[1]; + + if (!root && !dir) { + // No dirname whatsoever + return '.'; + } + + if (dir) { + // It has a dirname, strip trailing slash + dir = dir.substr(0, dir.length - 1); + } + + return root + dir; + } + + function basename(path, ext) { + var f = splitPath(path)[2]; + // TODO: make this comparison case-insensitive on windows? + if (ext && f.substr(-1 * ext.length) === ext) { + f = f.substr(0, f.length - ext.length); + } + // XXXfiler: node.js just does `return f` + return f === "" ? "/" : f; + } + + function isAbsolute(path) { + if(path.charAt(0) === '/') { + return true; + } + return false; + } + + function isNull(path) { + if (('' + path).indexOf('\u0000') !== -1) { + return true; + } + return false; + } + + function check(path) { + if(!path) { + throw new errors.EINVAL('path must be a string', path); + } else if(isNull(path)) { + throw new errors.EINVAL('path must be a string without null bytes', path); + } else if(!isAbsolute(path)) { + throw new errors.EINVAL('path must be absolute', path); + } + } + + const __$6 = new WeakMap(); + + class MemFS extends FS + { + constructor(options={}) + { + super(options); + + let storage = new Map(); + + let superNode = new SuperNode({ fs: this }); + storage.set(superNode.id, superNode); + + let rootNode = new Node({ fs: this, data: { mode: MODE_DIRECTORY } }); + storage.set(rootNode.id, rootNode); + + superNode.rnode = rootNode.id; + + __$6.set(this, { + storage: storage, + }); + } + + static get type() + { + return "memfs"; + } + + static async mount(dev=UUID.short(), flags=[], options={}) + { + let fs = new MemFS(); + + return fs; + } + + async umount() + { + super.umount(); + } + + async readNode(id) + { + let node = __$6.get(this).storage.get(id); + + if(!node) { + throw new errors.ENOENT(); + } + + return node; + } + + async writeNode(id, node) + { + __$6.get(this).storage.set(id, node); + } + + async readData(id, block=0) + { + let data = __$6.get(this).storage.get(`${id}${DATA_BLOCK_SEPARATOR}${block}`); + + if(!data) { + throw new errors.EIO(); + } + + return data; + } + + async writeData(id, block, data) + { + __$6.get(this).storage.set(`${id}${DATA_BLOCK_SEPARATOR}${block}`, data); + } + + async fsync() + { + + } + + async validate(id) + { + + } + } + + var Providers = { + [RootFS.type]: RootFS, + [MemFS.type]: MemFS, + }; + + const __$7 = new WeakMap(); + + class DirectoryEntry + { + constructor({ id, type=MODE_FILE } = {}) + { + __$7.set(this, { + id: id, + type: type, + }); + } + + get id() { return __$7.get(this).id } + + get type() { return __$7.get(this).type } + } + + const __$8 = new WeakMap(); + + const URL_REGEX = /^((\w+)\+(\w+):)?(\/\/((\w+)?(:(\w+))?@)?([^\/\?:]+)(:(\d+))?)?(\/?([^\/\?#][^\?#]*)?)?(\?([^#]+))?(#(\w*))?/i; + + class URL + { + constructor(urlString) + { + __$8.set(this, { + + }); + const self = __$8.get(this); + + let match = urlString.match(URL_REGEX); + + self.originalURL = match[0]; + + if(match[2]) { + self.protocol = match[2]; + } + + if(match[3]) { + self.subprotocol = match[3]; + } + + if(match[6]) { + self.username = match[6]; + } + + if(match[8]) { + self.password = match[8]; + } + + if(match[9]) { + self.host = match[9]; + } else { + self.host = ""; + } + + if(match[11]) { + self.port = match[11]; + } + + if(match[12]) { + self.path = match[12]; + } else { + self.path = ""; + } + + if(match[15]) { + let queryList = match[15].split("&"); + let query = {}; + for(let item of queryList) { + let [key, value] = item.split("="); + if(!(query.hasOwnProperty(key))) { + query[key] = []; + } + if(value) { + query[key].push(value); + } + } + self.query = query; + } else { + self.query = {}; + } + + if(match[17]) { + self.fragment = match[17]; + } else { + self.fragment = ""; + } + } + + get protocol() { return __$8.get(this).protocol } + set protocol(value) { return __$8.get(this).protocol = value } + + get subprotocol() { return __$8.get(this).subprotocol } + set subprotocol(value) { return __$8.get(this).subprotocol = value } + + get username() { return __$8.get(this).username } + set username(value) { return __$8.get(this).username = value } + + get password() { return __$8.get(this).password } + set password(value) { return __$8.get(this).password = value } + + get host() { return __$8.get(this).host } + set host(value) { return __$8.get(this).host = value } + + get port() { return __$8.get(this).port } + set port(value) { return __$8.get(this).port = value } + + get path() { return __$8.get(this).path } + set path(value) { return __$8.get(this).path = value } + + get query() { return __$8.get(this).query } + set query(value) { return __$8.get(this).query = value } + + get fragment() { return __$8.get(this).fragment } + set fragment(value) { return __$8.get(this).fragment = value } + + toJSON() + { + return { + protocol: this.protocol, + subprotocol: this.subprotocol, + username: this.username, + password: this.password, + host: this.host, + port: this.port, + path: this.path, + query: this.query, + fragment: this.fragment, + }; + } + } + + const __$9 = new WeakMap(); + + class InternalVFS + { + constructor() + { + const rootFS = new RootFS(); + const rootFSVFSMount = new VFSMount({ fs: rootFS, flags: [ MNT_READ_ONLY ] }); + const fsVFSMounts = new WeakMap(); + fsVFSMounts.set(rootFS, rootFSVFSMount); + + __$9.set(this, { + fdMap: new FDMap(), + + vfsMountsRoot: rootFSVFSMount, + fsVFSMounts: fsVFSMounts, + vfsMounts: new Map(), + }); + } + + async findNode({path, followSymlinks = true} = {}, context) + { + const self = __$9.get(this); + + if(!context) { + context = { symlinksFollowed: 0 }; + } + + path = normalize(path); + if(!path) { + throw new errors.ENOENT("path is an empty string"); + } + + let name = basename(path); + let parentPath = dirname(path); + + let fs; + let nodeId; + if(ROOT_DIRECTORY_NAME == name) { + fs = self.vfsMountsRoot.fs; + let superNode = await SuperNode.read(fs); + nodeId = superNode.rnode; + } else { + let parentDirectoryNode = await this.findNode({ path: parentPath }, context); + fs = parentDirectoryNode.fs; + + if(parentDirectoryNode.mode !== MODE_DIRECTORY) { + throw new errors.ENOTDIR("a component of the path prefix is not a directory", path); + } + + let parentDirectoryData; + try { + parentDirectoryData = await parentDirectoryNode.readData(); + } catch(error) { + parentDirectoryData = new Object(); + } + + if(!parentDirectoryData.hasOwnProperty(name)) { + throw new errors.ENOENT(null, path); + } + + let directoryEntry = new DirectoryEntry(parentDirectoryData[name]); + nodeId = directoryEntry.id; + } + + // Follow all vfsMounts on this node. + let nodeHash = Node.hash(fs, nodeId); + while(self.vfsMounts.has(nodeHash)) { + let vfsMount = (self.vfsMounts.get(nodeHash))[0]; + fs = vfsMount.fs; + + if(vfsMount.rnode) { + nodeId = vfsMount.rnode; + } else { + let superNode = await SuperNode.read(fs); + nodeId = superNode.rnode; + } + + nodeHash = Node.hash(fs, nodeId); + } + + let node = await Node.read(fs, nodeId); + + if(node.mode == MODE_SYMBOLIC_LINK) { + context.symlinksFollowed += 1; + + if(context.symlinksFollowed > SYMLOOP_MAX) { + throw new errors.ELOOP(null, path); + } + + let symlinkPath = await node.readData(); + node = await this.findNode({ path: symlinkPath }, context); + } + + return node; + } + + async mount(fsURL, mountPath, flags, options) + { + const self = __$9.get(this); + + let mountPoint = await this.findNode({ path: mountPath }); + + if(!mountPoint) { + throw new errors.ENOENT("mount target does not exist"); + } + + let url = new URL(fsURL); + + if("filer" !== url.protocol) { + throw new errors.UNKNOWN("expecting filer protocol"); + } + + let dev = url.path.slice(1); + let type = url.subprotocol; + + if(!(type in Providers)) { + throw new errors.UNKNOWN("unknown file system type"); + } + + let fs = await Providers[type].mount(dev, flags, options); + let superNode = await fs.readNode(SUPER_NODE_ID); + let rootNode = await fs.readNode(superNode.rnode); + + let vfsMount = new VFSMount({ parent: self.fsVFSMounts.get(mountPoint.fs), flags: flags, fs: fs }); + self.fsVFSMounts.set(fs, vfsMount); + + if(!self.vfsMounts.has(mountPoint.hash())) { + self.vfsMounts.set(mountPoint.hash(), new Array()); + } + self.vfsMounts.get(mountPoint.hash()).unshift(vfsMount); + } + + async umount(path) + { + const self = __$9.get(this); + + let mountPoint = await this.findNode({ path: path }); + console.log(self.vfsMounts.keys(), mountPoint.hash()); + if(!self.vfsMounts.has(mountPoint.hash())) { + throw new errors.EINVAL(null, path); + } + + let vfsMount = self.vfsMounts.get(mountPoint.hash()); + if(vfsMount.hasChildren()) { + throw new errors.EBUSY(null, path); + } + } + + open(path, flags, mode, callback) + { + + } + + close(fd, callback) + { + + } + + mknod(path, mode, callback) + { + + } + + async mkdir(path, mode) + { + path = normalize(path); + + let name = basename(path); + let parentPath = dirname(path); + + let directoryNode; + try { + directoryNode = await this.findNode({ path: path }); + } catch(error) { + directoryNode = null; + } + + if(directoryNode) { + console.log(directoryNode.toJSON()); + throw new errors.EEXIST(null, path); + } + + let parentDirectoryNode = await this.findNode({ path: parentPath }); + let fs = parentDirectoryNode.fs; + + let parentDirectoryData; + try { + parentDirectoryData = await parentDirectoryNode.readData(); + } catch(error) { + parentDirectoryData = new Object(); + } + + directoryNode = new Node({ fs: fs, data: { mode: MODE_DIRECTORY, nlinks: 1, data: UUID.short() } }); + directoryNode.write(); + + let directoryData = new Object(); + await directoryNode.writeData(0, directoryData); + + // ! update node a/c/m times + + parentDirectoryData[name] = new DirectoryEntry({ id: directoryNode.id, type: MODE_DIRECTORY }); + await parentDirectoryNode.writeData(0, parentDirectoryData); + + parentDirectoryNode.size = Object.keys(parentDirectoryData).length; + await parentDirectoryNode.write(); + } + + async readdir(path) + { + check(path); + + let directoryNode = await this.findNode({ path: path }); + let directoryData; + try { + directoryData = await directoryNode.readData(); + } catch(error) { + if(error instanceof errors.EIO) + directoryData = new Object(); + } + + let files = Object.keys(directoryData); + return files; + } + + rmdir(path, callback) + { + + } + + stat(path, callback) + { + + } + + fstat(fd, callback) + { + + } + + link(oldpath, newpath, callback) + { + + } + + unlink(path, callback) + { + + } + + read(fd, buffer, offset, length, position, callback) + { + + } + + readFile(path, options, callback) + { + + } + + write(fd, buffer, offset, length, position, callback) + { + + } + + writeFile(path, data, options, callback) + { + + } + + appendFile(path, data, options, callback) + { + + } + + exists(path, callback) + { + + } + + getxattr(path, name, callback) + { + + } + + fgetxattr(fd, name, callback) + { + + } + + setxattr(path, name, value, flag, callback) + { + + } + + fsetxattr(fd, name, value, flag, callback) + { + + } + + removexattr(path, name, callback) + { + + } + + fremovexattr(fd, name, callback) + { + + } + + lseek(fd, offset, whence, callback) + { + + } + + utimes(path, atime, mtime, callback) + { + + } + + futimes(fd, atime, mtime, callback) + { + + } + + rename(oldpath, newpath, callback) + { + + } + + symlink(srcpath, dstpath, type, callback) + { + + } + + readlink(path, callback) + { + + } + + lstat(path, callback) + { + + } + + truncate(path, length, callback) + { + + } + + ftruncate(fd, length, callback) + { + + } + } + class VFS + { + constructor() + { + __$9.set(this, { + vfs: new InternalVFS(), + }); + } + + async mount(...args) { return await __$9.get(this).vfs.mount(...args); } + + async umount(...args) { return await __$9.get(this).vfs.umount(...args); } + + async mkdir(...args) { return await __$9.get(this).vfs.mkdir(...args); } + + async readdir(...args) { return await __$9.get(this).vfs.readdir(...args); } + } + + var index = { + FS: FS, + VFS: VFS, + UUID: UUID, + Buffer: Buffer, + Crypto: Crypto$1, + }; + + return index; + +}))); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"filer.js","sources":["../src/common/platform.js","../src/common/errors.js","../src/common/crypto.js","../src/common/uuid.js","../src/fs/fs.js","../src/common/buffer.js","../src/common/constants.js","../src/vfs/fdmap.js","../src/vfs/vfsmount.js","../src/fs/super-node.js","../src/fs/node.js","../src/fs/providers/root-fs.js","../src/common/path.js","../src/fs/providers/mem-fs.js","../src/fs/providers/index.js","../src/vfs/directory-entry.js","../src/common/url.js","../src/vfs/vfs.js","../src/index.js"],"sourcesContent":["class Platform\n{\n\tstatic supportsWebCrypto()\n\t{\n\t\treturn (\"undefined\" !== typeof window && \n\t\t\t\t\"undefined\" !== typeof window.crypto &&\n\t\t\t\t\"function\" === typeof window.crypto.getRandomValues);\n\t}\n\n\tstatic supportsNodeCrypto()\n\t{\n\t\tif(\"undefined\" !== typeof process) {\n\t\t\ttry {\n\t\t\t\trequire.resolve(\"crypto\");\n\t\t\t\treturn true;\n\t\t\t} catch(e) {\t\t\t\t\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n}\n\nexport default Platform;","class FilerError extends Error\n{\n\tconstructor(message, path = null)\n\t{\n\t\tsuper(message);\n\n\t\tthis.path = path;\n\t}\n}\n\nconst errors = {};\nconst errorDefinitions = \n[\n\t{ errno: -1, name: \"UNKNOWN\", text: \"unknown error\" },\n\t{ errno: 0, name: \"OK\", text: \"success\" },\n\t{ errno: 1, name: \"EOF\", text: \"end of file\" },\n\n\t{ errno: 9, name: \"EBADF\", text: \"bad file descriptor\" },\n\t{ errno: 10, name: \"EBUSY\", text: \"resource busy or locked\" },\n\n\t{ errno: 18, name: \"EINVAL\", text: \"invalid argument\" },\n\n\t{ errno: 27, name: \"ENOTDIR\", text: \"not a directory\" },\n\t{ errno: 28, name: \"EISDIR\", text: \"illegal operation on directory\" },\n\n\t{ errno: 34, name: \"ENOENT\", text: \"no such file or directory\" },\n\n\t{ errno: 47, name: \"EEXIST\", text: \"file already exists\" },\n\n\t{ errno: 50, name: \"EPERM\", text: \"operation not permitted\" },\n\t{ errno: 51, name: \"ELOOP\", text: \"too many symbolic links encountered\" },\n\n\t{ errno: 53, name: \"ENOTEMPTY\", text: \"directory not empty\" },\n\n\t{ errno: 55, name: \"EIO\", text: \"i/o error\" },\n\t{ errno: 56, name: \"EROFS\", text: \"read-only file system\" },\n\t{ errno: 57, name: \"ENODEV\", text: \"no such device\" },\n\n\t{ errno: 58, name: \"ECANCELED\", text: \"operation canceled\" },\n\n\t{ errno: 1000, name: \"ENOTSUPPORTED\", text: \"platform is not supported\" },\n]\n\nfor (let error of errorDefinitions) {\n\terrors[error.errno] = errors[error.name] = class extends FilerError {\n\t\tconstructor(message, path)\n\t\t{\n\t\t\tsuper(message || error.text, path);\n\t\t}\n\n\t\tget name() { return error.name }\n\n\t\tget code() { return error.name }\n\n\t\tget errno() { return error.errno }\n\n\t\tget message() { return this.message }\t\t\n\n\t\tget stack() { return (new Error(this.message)).stack }\n\n\t\tget toString() { \n\t\t\tpathInfo = this.path ? (', \\'' + this.path + '\\'') : '';\n\t\t\treturn `${this.name}: ${this.message}${pathInfo}`; \n\t\t}\n\t}\n}\n\nexport default errors;","import Platform from \"./platform\";\nimport E from \"./errors\";\n\nlet Crypto;\nif(Platform.supportsWebCrypto()) {\n\tCrypto = class Crypto\n\t{\n\t\tstatic randomBytes(arrayBuffer)\n\t\t{\n\t\t\treturn window.crypto.getRandomValues(arrayBuffer);\n\t\t}\n\t}\n} else if(Platform.supportsNodeCrypto()) {\n\tlet nodeCrypto = require(\"crypto\");\n\tCrypto = class Crypto\n\t{\n\t\tstatic randomBytes(arrayBuffer)\n\t\t{\n\t\t\treturn nodeCrypto.randomFillSync(arrayBuffer);\n\t\t}\n\t}\n} else {\n\tthrow new E.ENOTSUPPORTED(\"crypto support is not available on this platform\");\n}\n\nexport default Crypto;","import Crypto from \"./crypto\";\n\nconst UUID_SHORT_REGEX = /^[0-9a-zA-Z]{22}$/;\nconst BASE = \"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\".split('');\nconst BASE_MAP = {};\n\nfor (var z = 0; z < BASE.length; z += 1) {\n    var x = BASE[z];\n\n    if (BASE_MAP[x] !== undefined) throw new TypeError(`${x} is ambiguous`)\n      BASE_MAP[x] = z;\n}\n\nfunction encode(source) {\n    if (source.length === 0) return ''\n\n    var digits = [0]\n    for (var i = 0; i < source.length; ++i) {\n      for (var j = 0, carry = source[i]; j < digits.length; ++j) {\n        carry += digits[j] << 8\n        digits[j] = carry % BASE.length\n        carry = (carry / BASE.length) | 0\n      }\n\n      while (carry > 0) {\n        digits.push(carry % BASE.length)\n        carry = (carry / BASE.length) | 0\n      }\n    }\n\n    var string = \"\";\n\n    for (var k = 0; source[k] === 0 && k < source.length - 1; ++k) \n      string += BASE[0];\n\n    for (var q = digits.length - 1; q >= 0; --q) \n      string += BASE[digits[q]];\n\n    return string\n}\n\nclass UUID {\n  static v4()\n  {\n    let buffer = new Uint8Array(16);\n    Crypto.randomBytes(buffer);\n\n    buffer[6] &= 0b00001111;\n    buffer[6] |= 0b01000000;\n\n    buffer[8] &= 0b00111111;\n    buffer[8] |= 0b10000000;\n\n    return encode(buffer);\n  }\n\n  static short()\n  {\n    return this.v4();\n  }\n}\n\nexport default UUID;","import UUID from \"../common/uuid\";\n\nconst __ = new WeakMap();\n\nclass FS\n{\n\tconstructor(superNode, options)\n\t{\n\t\tlet { proxy, revoke } = Proxy.revocable(this, {});\n\n\t\t__.set(proxy, {\n\t\t\tid: UUID.short(),\t// instance ID\n\t\t\trevoke: revoke,\n\t\t});\n\n\t\treturn proxy;\n\t}\t\n\n\tget id()\n\t{\n\t\treturn __.get(this).id;\n\t}\n\n\tstatic async mount(dev, flags=[], options={})\n\t{\n\n\t}\n\n\tasync umount()\n\t{\n\t\t__.get(this).revoke();\n\t}\n\n\ttoString()\n\t{\n\t\treturn this.id;\n\t}\n}\n\nexport default FS;","const INSPECT_MAX_BYTES = 50;\nconst K_MAX_LENGTH = 0x7fffffff;\n\nclass Buffer extends Uint8Array\n{\n\tconstructor(arg, encodingOrOffset, length)\n\t{\n\t\tif (typeof arg === \"number\") {\n\t\t    if (typeof encodingOrOffset === \"string\") {\n\t\t      throw new TypeError(`The \"string\" argument must be of type string. Received type number`);\n\t\t    }\n\t\t    return allocUnsafe(arg);\n\t\t  }\n\t\treturn from(arg, encodingOrOffset, length);\n\t}\n\n\tstatic get INSPECT_MAX_BYTES() { return 50 }\n\n\tstatic get K_MAX_LENGTH() { return 0x7fffffff }\n\n\tstatic isSupported()\n\t{\n\t\ttry {\n\t\t    var arr = new Uint8Array(1)\n\t\t    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n\t\t    return arr.foo() === 42\n\t\t  } catch (e) {\n\t\t    return false\n\t\t}\n\t}\n\n\tstatic from(value, encodingOrOffset, length)\n\t{\n\t  if (typeof value === 'string') {\n\t    return fromString(value, encodingOrOffset)\n\t  }\n\n\t  if (ArrayBuffer.isView(value)) {\n\t    return fromArrayLike(value)\n\t  }\n\n\t  if (value == null) {\n\t    throw TypeError(`The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type ${typeof value}`);\n\t  }\n\n\t  if (isInstance(value, ArrayBuffer) ||\n\t      (value && isInstance(value.buffer, ArrayBuffer))) {\n\t    return fromArrayBuffer(value, encodingOrOffset, length)\n\t  }\n\n\t  if (typeof value === 'number') {\n\t    throw new TypeError(\n\t      'The \"value\" argument must not be of type number. Received type number'\n\t    )\n\t  }\n\n\t  var valueOf = value.valueOf && value.valueOf();\n\t  if(valueOf != null && valueOf !== value) {\n\t    return Buffer.from(valueOf, encodingOrOffset, length);\n\t  }\n\n\t  var b = fromObject(value);\n\t  if(b) {\n\t  \treturn b;\n\t  }\n\n\t  if(typeof Symbol !== \"undefined\" && Symbol.toPrimitive != null &&\n\t      typeof value[Symbol.toPrimitive] === \"function\") {\n\t    return Buffer.from(value[Symbol.toPrimitive](\"string\"), encodingOrOffset, length);\n\t  }\n\n\t  throw new TypeError(`The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type ${typeof value}`);\n\t}\n}\n\nexport default Buffer;","import Buffer from \"./buffer\";\n\nexport const SUPER_NODE_ID = \"0000000000000000000000\";\n\nexport const MODE_FILE = \"FILE\";\nexport const MODE_DIRECTORY = \"DIRECTORY\";\nexport const MODE_SYMBOLIC_LINK = \"MODE_SYMBOLIC_LINK\";\nexport const MODE_META = \"META\";\nexport const MODE_SOCKET = \"SOCKET\";\nexport const MODE_FIFO = \"FIFO\";\nexport const MODE_CHARACTER_DEVICE = \"CHARACTER_DEVICE\";\nexport const MODE_BLOCK_DEVICE = \"BLOCK_DEVICE\";\n\nexport const ROOT_DIRECTORY_NAME = \"/\"; // basename(normalize(path))\n\nexport const STDIN = 0;\nexport const STDOUT = 1;\nexport const STDERR = 2;\n\nexport const FIRST_DESCRIPTOR = 3;\n\nexport const N_VFS_DESCRIPTORS = 1024;\n\nexport const DATA_BLOCK_SEPARATOR = \"#\";\n\nexport const MNT_READ_ONLY = \"READ_ONLY\";\n\nexport const SYMLOOP_MAX = 10;","import { FIRST_DESCRIPTOR, N_VFS_DESCRIPTORS, STDIN, STDOUT, STDERR } from \"../common/constants\";\n\nconst __ = new WeakMap();\n\nclass FDMap\n{\n\tconstructor(size=N_VFS_DESCRIPTORS)\n\t{\n\t\tconst map = new Array(size).fill(0);\n\n\t\tmap[STDIN] = 1;\n\t\tmap[STDOUT] = 1;\n\t\tmap[STDERR] = 1;\n\n\t\t__.set(this, {\n\t\t\tmap: map,\n\t\t\tnext: FIRST_DESCRIPTOR,\n\t\t});\n\t}\n\n\tclaimUnused()\n\t{\t\t\n\t\tconst map = __.get(this).map;\n\t\tlet next = __.get(this).next;\n\n\t\tfor(let i = 0; i < map.length; ++ i)\n\t\t{\n\t\t\tlet fd = (next+i) % map.length;\n\t\t\tif(0 == map[fd]) {\n\t\t\t\tthis.claim(fd);\n\t\t\t\treturn fd;\n\t\t\t}\n\t\t}\n\n\t\tthrow new Error(`unable to allocate file descriptor`);\n\t}\n\n\tclaim(fd)\n\t{\t\t\n\t\t__.get(this).map[fd] = 1;\n\t}\n\n\trelease(fd)\n\t{\n\t\t__.get(this).map[fd] = 0;\n\t}\n}\n\nexport default FDMap;","const __ = new WeakMap();\n\nclass VFSMount\n{\n\tconstructor({ parentVFSMount = null, flags = [], fs, rnode = null } = {})\n\t{\n\t\t__.set(this, {\n\t\t\tflags: flags,\n\t\t\tfs: fs,\n\t\t\trnode: rnode,\n\n\t\t\tparent: parentVFSMount,\n\t\t\tchildren: new Set(),\n\t\t});\n\n\t\tif(parentVFSMount) {\n\t\t\tparentVFSMount.insertChild(this);\n\t\t}\n\t}\n\n\tget fs() { return __.get(this).fs }\n\n\tget rnode() { return __.get(this).rnode }\n\n\tget flags() { return __.get(this).flags }\n\n\tget parent() { return __.get(this).parent }\n\n\tget children() { return __.get(this).children }\n\n\thasChildren()\n\t{\n\t\tconst self = __.get(this);\n\n\t\treturn this.children.size > 0;\n\t}\n\n\tinsertChild(vfsMount)\n\t{\n\t\tconst self = __.get(this);\n\t\t\n\t\tself.children.add(vfsMount);\n\t}\n\n\tremoveChild(vfsMount)\n\t{\n\t\tconst self = __.get(this);\n\n\t\tself.children.delete(vfsMount);\n\t}\n};\n\nexport default VFSMount;","import { MODE_META } from \"../common/constants\";\nimport { SUPER_NODE_ID } from \"../common/constants\";\nimport UUID from \"../common/uuid\";\n\nconst __ = new WeakMap();\n\nclass SuperNodeData\n{\n\tconstructor({ dev, atime = Date.now(), mtime = Date.now(), ctime = Date.now(), rnode, version = UUID.short() } = {})\n\t{\n\t\t__.set(this, {\n\t\t\tdev: dev,\n\t\t\tmode: MODE_META,\n\t\t\tatime: atime || Date.now(), // access time (will mirror ctime after creation)\n\t\t\tmtime: mtime || Date.now(), // creation/change time\n\t\t\tctime: ctime || Date.now(), // modified time\n\t\t\trnode: rnode, // root node\n\t\t\tversion: version,\n\t\t});\n\t}\n\n\tget dev() { return __.get(this).dev }\n\n\tget mode() { return __.get(this).mode }\n\n\tget atime() { return __.get(this).atime }\n\tset atime(value) { return __.get(this).atime = value }\n\n\tget mtime() { return __.get(this).mtime }\n\tset mtime(value) { return __.get(this).mtime = value }\n\n\tget ctime() { return __.get(this).ctime }\n\tset ctime(value) { return __.get(this).ctime = value }\n\n\tget version() { return __.get(this).version }\n\tset version(value) { return __.get(this).version = value }\n\n\tget rnode() { return __.get(this).rnode }\n\tset rnode(value) { return __.get(this).rnode = value }\n\n\ttoJSON()\n\t{\n\t\treturn {\n\t\t\tdev: this.dev,\n\t\t\tmode: this.mode,\n\t\t\tatime: this.atime,\n\t\t\tmtime: this.mtime,\n\t\t\tctime: this.ctime,\n\t\t\trnode: this.rnode,\n\t\t\tversion: this.version,\n\t\t};\n\t}\n}\n\nclass SuperNode\n{\n\tconstructor({ fs, data } = {})\n\t{\n\t\t__.set(this, {\n\t\t\tfs: fs,\n\t\t\tid: SUPER_NODE_ID,\t\t\t\n\n\t\t\tdata: new SuperNodeData(data),\n\t\t});\n\t}\n\n\tget id() { return __.get(this).id }\n\n\tget fs() { return __.get(this).fs }\n\n\tget dev() {\treturn __.get(this).data.dev }\n\n\tget mode() { return __.get(this).data.mode }\n\n\tget atime() { return __.get(this).data.atime }\n\tset atime(value) { return __.get(this).data.atime = value }\n\n\tget mtime() { return __.get(this).data.mtime }\n\tset mtime(value) { return __.get(this).data.mtime = value }\n\n\tget ctime() { return __.get(this).data.ctime }\n\tset ctime(value) { return __.get(this).data.ctime = value }\t\n\n\tget rnode() { return __.get(this).data.rnode }\n\tset rnode(value) { return __.get(this).data.rnode = value }\n\n\tget version() { return __.get(this).data.version }\n\tset version(value) { return __.get(this).data.version = value }\n\n\tget data() { return __.get(this).data.toJSON() }\n\n\tstatic async read(fs)\n\t{\n\t\tlet data = await fs.readNode(SUPER_NODE_ID);\n\t\treturn new SuperNode({ fs: fs, data: data });\n\t}\n\n\tasync read()\n\t{\n\t\tlet data = await this.fs.readNode(this.id);\n\t\t__.get(this).data = new SuperNodeData(data);\n\t}\n\n\tasync write()\n\t{\n\t\tthis.version = UUID.short();\n\t\tawait fs.writeNode(this.id, this.data);\n\t}\n\n\ttoJSON()\n\t{\n\t\treturn {\n\t\t\tid: this.id,\n\t\t\tdata: __.get(this).data.toJSON(),\n\t\t}\n\t}\t\n\n\ttoString()\n\t{\n\t\treturn JSON.stringify(this.toJSON());\n\t}\n}\n\nexport default SuperNode;","import UUID from \"../common/uuid\";\nimport { MODE_FILE, MODE_DIRECTORY, MODE_SYMBOLIC_LINK } from \"../common/constants\";\nimport Buffer from \"../common/buffer\";\nimport E from \"../common/errors\";\n\nconst __ = new WeakMap();\n\nclass NodeData\n{\n\tconstructor({ mode, size = 0, atime, mtime, ctime, version = UUID.short(), flags, xattrs, nlinks, blksize, nblocks, blkid = UUID.short() })\n\t{\n\t\t__.set(this, {\n\t\t\tmode: mode, // node type (file, directory, etc)\n\t\t\tsize: size,\n\t\t\tatime: atime || Date.now(), // access time (will mirror ctime after creation)\n\t\t\tmtime: mtime || Date.now(), // creation/change time\n\t\t\tctime: ctime || Date.now(), // modified time\n\t\t\tversion: version || UUID.short(),\n\t\t\tflags: flags || [],\n\t\t\txattrs: xattrs || {},\n\t\t\tnlinks: nlinks || 0,\n\t\t\tblksize: blksize || 4096,\n\t\t\tnblocks: nblocks || 0,\n\t\t\tblkid: blkid,\n\t\t});\n\t}\n\n\tget mode() { return __.get(this).mode }\n\n\tget atime() { return __.get(this).atime }\n\tset atime(value) { return __.get(this).atime = value }\n\n\tget mtime() { return __.get(this).mtime }\n\tset mtime(value) { return __.get(this).mtime = value }\n\n\tget ctime() { return __.get(this).ctime }\n\tset ctime(value) { return __.get(this).ctime = value }\n\n\tget version() { return __.get(this).version }\n\tset version(value) { return __.get(this).version = value }\n\n\tget flags() { return __.get(this).flags }\n\t\n\tget xattrs() { return __.get(this).xattrs }\n\n\tget nlinks() { return __.get(this).nlinks }\n\tset nlinks(value) { return __.get(this).nlinks = value }\n\n\tget blksize() { return __.get(this).blksize }\n\t\n\tget nblocks() { return __.get(this).nblocks }\n\tset nblocks(value) { return __.get(this).nblocks = value }\n\n\tget blkid() { return __.get(this).blkid }\n\tset blkid(value) { return __.get(this).blkid = value }\n\n\tget size() { return __.get(this).size }\n\tset size(value) { return __.get(this).size = value }\t\n\n\ttoJSON()\n\t{\n\t\treturn {\n\t\t\tmode: this.mode,\n\t\t\tsize: this.size,\n\t\t\tatime: this.atime,\n\t\t\tmtime: this.mtime,\n\t\t\tctime: this.ctime,\n\t\t\tnlinks: this.nlinks,\n\t\t\tversion: this.version,\n\t\t\tblksize: this.blksize,\n\t\t\tnblocks: this.nblocks,\n\t\t\tblkid: this.blkid,\n\t\t\tflags: this.flags,\n\t\t\txattrs: this.xattrs,\n\t\t};\n\t}\t\n}\n\nclass Node\n{\n\tconstructor({ fs, id = UUID.short(), data } = {})\n\t{\n\t\t__.set(this, {\n\t\t\tfs: fs,\n\t\t\tid: id,\t\t\t\n\n\t\t\tdata: new NodeData(data),\n\t\t});\n\t}\n\n\tget fs() { return __.get(this).fs }\n\n\tget id() { return __.get(this).id }\n\t\n\tget size() { return __.get(this).data.size }\n\tset size(value) { return __.get(this).data.size = value }\n\n\tget nlinks() { return __.get(this).data.nlinks }\n\tset nlinks(value) { return __.get(this).data.nlinks = value }\n\n\tget version() { return __.get(this).data.version }\n\tset version(value) { return __.get(this).data.version = value }\n\n\tget blksize() { return __.get(this).data.blksize }\n\n\tget nblocks() {\treturn __.get(this).data.nblocks\t}\n\tset nblocks(value) { return __.get(this).data.nblocks = value }\n\n\tget atime()\t{ return __.get(this).data.atime }\n\tset atime(value) { return __.get(this).data.atime = value }\n\n\tget mtime() { return __.get(this).data.mtime }\n\tset mtime(value) { return __.get(this).data.mtime = value }\n\n\tget ctime() { return __.get(this).data.ctime }\n\tset ctime(value) { return __.get(this).data.ctime = value }\n\n\tget mode() { return __.get(this).data.mode }\n\n\tget blkid() { return __.get(this).data.blkid }\n\tset blkid(value) { return __.get(this).data.blkid = value }\n\n\tget flags() { return __.get(this).data.flags }\n\n\tget xattrs() { return __.get(this).data.xattrs }\n\n\tget data() { return __.get(this).data.toJSON() }\n\n\tisFile() \n\t{ \n\t\treturn MODE_FILE == this.mode;\n\t}\n\n\tisDirectory() \n\t{\n\t\treturn MODE_DIRECTORY == this.mode;\n\t}\n\n\tisSymbolicLink()\n\t{\n\t\treturn MODE_SYMBOLIC_LINK == this.mode;\n\t}\n\n\tisSocket()\n\t{\n\t\treturn MODE_SOCKET == this.mode;\n\t}\n\n\tisFIFO()\n\t{\n\t\treturn MODE_FIFO == this.mode;\n\t}\n\n\tisCharacterDevice()\n\t{\n\t\treturn MODE_CHARACTER_DEVICE == this.mode;\n\t}\n\n\tisBlockDevice()\n\t{\n\t\treturn MODE_BLOCK_DEVICE == this.mode;\n\t}\n\n\ttoString()\n\t{\n\t\treturn JSON.stringify(this.toJSON());\n\t}\n\n\tstatic hash(fs, id)\n\t{\n\t\treturn `${fs.id}${id}`;\n\t}\n\n\thash()\n\t{\n\t\treturn Node.hash(this.fs, this.id);\n\t}\n\n\tstatic async read(fs, id)\n\t{\n\t\tlet data = await fs.readNode(id);\n\t\treturn new Node({ fs: fs, id: id, data: data });\n\t}\n\n\tasync read()\n\t{\n\t\tlet data = await this.fs.readNode(this.id);\n\t\t__.get(this).data = new NodeData(data);\n\t}\n\n\tasync write()\n\t{\n\t\tthis.version = UUID.short();\n\t\treturn await this.fs.writeNode(this.id, this.data);\n\t}\n\n\tasync readData(block=0)\n\t{\n\t\tlet data = await this.fs.readData(this.blkid, block);\n\n\t\treturn data;\n\t}\n\n\tasync writeData(block=0, data)\n\t{\n\t\tthis.nblocks = block + 1;\n\t\tawait this.fs.writeData(this.blkid, block, data);\n\t}\n\n\tasync validate()\n\t{\n\t\t\n\t}\n\n\ttoJSON()\n\t{\n\t\treturn {\n\t\t\tfs: this.fs.id,\n\t\t\tid: this.id,\n\t\t\tdata: __.get(this).data.toJSON(),\n\t\t}\n\t}\t\n\n\ttoString()\n\t{\n\t\treturn JSON.stringify(this.toJSON());\n\t}\n}\n\nexport default Node;","import FS from \"../fs\";\nimport SuperNode from \"../super-node\";\nimport Node from \"../node\";\nimport UUID from \"../../common/uuid\";\nimport { MODE_DIRECTORY, MODE_FILE, DATA_BLOCK_SEPARATOR } from \"../../common/constants\";\nimport { SUPER_NODE_ID } from \"../../common/constants\";\nimport E from \"../../common/errors\";\n\nconst __ = new WeakMap();\n\n/*\n\tRootFS is a read-only file system containing exactly one\n\tdirectory node. It is created automatically by the VFS\n\tlayer. Its only purpose is to allow the VFS to mount another\n\tfile system on top of its only node.\n */\n\nclass RootFS extends FS\n{\n\tconstructor(options={})\n\t{\t\t\n\t\tsuper(options);\n\n\t\tlet superNode = new SuperNode({ fs: this, data: { dev: UUID.short() } });\n\n\t\tlet rootNode = new Node({ fs: this, data: { mode: MODE_DIRECTORY, nlinks: 1 } });\n\t\tsuperNode.rnode = rootNode.id;\n\n\t\tlet storage = new Map();\n\t\tstorage.set(superNode.id, superNode.data);\n\t\tstorage.set(rootNode.id, rootNode.data);\n\n\t\t__.set(this, {\n\t\t\tstorage: storage,\n\t\t});\n\t}\n\n\tstatic get type()\n\t{\n\t\treturn \"rootfs\";\n\t}\n\n\tstatic async mount()\n\t{\n\t\tthrow new E.UNKNOWN(\"mount operation not available for rootfs\");\n\t}\n\n\tasync umount()\n\t{\n\t\tthrow new E.UNKNOWN(\"umount operation not available for rootfs\");\n\t}\t\n\n\tasync readNode(id)\n\t{\n\t\tlet node = __.get(this).storage.get(id);\t\t\n\n\t\tif(!node) {\n\t\t\tthrow new E.ENOENT();\n\t\t}\n\n\t\treturn node;\n\t}\n\n\tasync writeNode(id, node)\n\t{\n\t\tthrow new E.EROFS();\n\t}\n\n\tasync readData(id, block=0)\n\t{\n\t\tlet data = __.get(this).storage.get(`${id}${DATA_BLOCK_SEPARATOR}${block}`);\n\n\t\tif(!data) {\n\t\t\tthrow new E.EIO();\n\t\t}\n\n\t\treturn data;\n\t}\n\n\tasync writeData(id, block, data)\n\t{\n\t\tthrow new E.EROFS();\n\t}\n\n\tasync fsync()\n\t{\n\n\t}\n\n\tasync validate(id)\n\t{\n\n\t}\n}\n\nexport default RootFS;","import E from \"./errors\";\n\nfunction normalizeArray(parts, allowAboveRoot) {\n  // if the path tries to go above the root, `up` ends up > 0\n  var up = 0;\n  for (var i = parts.length - 1; i >= 0; i--) {\n    var last = parts[i];\n    if (last === '.') {\n      parts.splice(i, 1);\n    } else if (last === '..') {\n      parts.splice(i, 1);\n      up++;\n    } else if (up) {\n      parts.splice(i, 1);\n      up--;\n    }\n  }\n\n  // if the path is allowed to go above the root, restore leading ..s\n  if (allowAboveRoot) {\n    for (; up--; up) {\n      parts.unshift('..');\n    }\n  }\n\n  return parts;\n}\n\n// Split a filename into [root, dir, basename, ext], unix version\n// 'root' is just a slash, or nothing.\nvar splitPathRe =\n      /^(\\/?)([\\s\\S]+\\/(?!$)|\\/)?((?:\\.{1,2}$|[\\s\\S]+?)?(\\.[^.\\/]*)?)$/;\nvar splitPath = function(filename) {\n  var result = splitPathRe.exec(filename);\n  return [result[1] || '', result[2] || '', result[3] || '', result[4] || ''];\n};\n\n// path.resolve([from ...], to)\nexport function resolve() {\n  var resolvedPath = '',\n      resolvedAbsolute = false;\n\n  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n    // XXXfiler: we don't have process.cwd() so we use '/' as a fallback\n    var path = (i >= 0) ? arguments[i] : '/';\n\n    // Skip empty and invalid entries\n    if (typeof path !== 'string' || !path) {\n      continue;\n    }\n\n    resolvedPath = path + '/' + resolvedPath;\n    resolvedAbsolute = path.charAt(0) === '/';\n  }\n\n  // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n\n  // Normalize the path\n  resolvedPath = normalizeArray(resolvedPath.split('/').filter(function(p) {\n    return !!p;\n  }), !resolvedAbsolute).join('/');\n\n  return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';\n}\n\n// path.normalize(path)\nexport function normalize(path) {\n  var isAbsolute = path.charAt(0) === '/',\n      trailingSlash = path.substr(-1) === '/';\n\n  // Normalize the path\n  path = normalizeArray(path.split('/').filter(function(p) {\n    return !!p;\n  }), !isAbsolute).join('/');\n\n  if (!path && !isAbsolute) {\n    path = '.';\n  }\n  /*\n   if (path && trailingSlash) {\n   path += '/';\n   }\n   */\n\n  return (isAbsolute ? '/' : '') + path;\n}\n\nexport function join() {\n  var paths = Array.prototype.slice.call(arguments, 0);\n  return normalize(paths.filter(function(p, index) {\n    return p && typeof p === 'string';\n  }).join('/'));\n}\n\n// path.relative(from, to)\nexport function relative(from, to) {\n  from = resolve(from).substr(1);\n  to = resolve(to).substr(1);\n\n  function trim(arr) {\n    var start = 0;\n    for (; start < arr.length; start++) {\n      if (arr[start] !== '') break;\n    }\n\n    var end = arr.length - 1;\n    for (; end >= 0; end--) {\n      if (arr[end] !== '') break;\n    }\n\n    if (start > end) return [];\n    return arr.slice(start, end - start + 1);\n  }\n\n  var fromParts = trim(from.split('/'));\n  var toParts = trim(to.split('/'));\n\n  var length = Math.min(fromParts.length, toParts.length);\n  var samePartsLength = length;\n  for (var i = 0; i < length; i++) {\n    if (fromParts[i] !== toParts[i]) {\n      samePartsLength = i;\n      break;\n    }\n  }\n\n  var outputParts = [];\n  for (var i = samePartsLength; i < fromParts.length; i++) {\n    outputParts.push('..');\n  }\n\n  outputParts = outputParts.concat(toParts.slice(samePartsLength));\n\n  return outputParts.join('/');\n}\n\nexport function dirname(path) {\n  var result = splitPath(path),\n      root = result[0],\n      dir = result[1];\n\n  if (!root && !dir) {\n    // No dirname whatsoever\n    return '.';\n  }\n\n  if (dir) {\n    // It has a dirname, strip trailing slash\n    dir = dir.substr(0, dir.length - 1);\n  }\n\n  return root + dir;\n}\n\nexport function basename(path, ext) {\n  var f = splitPath(path)[2];\n  // TODO: make this comparison case-insensitive on windows?\n  if (ext && f.substr(-1 * ext.length) === ext) {\n    f = f.substr(0, f.length - ext.length);\n  }\n  // XXXfiler: node.js just does `return f`\n  return f === \"\" ? \"/\" : f;\n}\n\nexport function extname(path) {\n  return splitPath(path)[3];\n}\n\nexport function isAbsolute(path) {\n  if(path.charAt(0) === '/') {\n    return true;\n  }\n  return false;\n}\n\nexport function isNull(path) {\n  if (('' + path).indexOf('\\u0000') !== -1) {\n    return true;\n  }\n  return false;\n}\n\n// Make sure we don't double-add a trailing slash (e.g., '/' -> '//')\nexport function addTrailing(path) {\n  return path.replace(/\\/*$/, '/');\n}\n\n// Deal with multiple slashes at the end, one, or none\n// and make sure we don't return the empty string.\nexport function removeTrailing(path) {\n  path = path.replace(/\\/*$/, '');\n  return path === '' ? '/' : path;\n}\n\nexport function check(path) {\n  if(!path) {\n    throw new E.EINVAL('path must be a string', path);\n  } else if(isNull(path)) {\n    throw new E.EINVAL('path must be a string without null bytes', path);\n  } else if(!isAbsolute(path)) {\n    throw new E.EINVAL('path must be absolute', path);\n  }\n}","import FS from \"../index\";\nimport SuperNode from \"../super-node\";\nimport Node from \"../node\";\nimport UUID from \"../../common/uuid\";\nimport E from \"../../common/errors\";\nimport { MODE_FILE, MODE_DIRECTORY, DATA_BLOCK_SEPARATOR } from \"../../common/constants\";\nimport Buffer from \"../../common/buffer\";\n\nconst __ = new WeakMap();\n\nclass MemFS extends FS\n{\n\tconstructor(options={})\n\t{\t\t\n\t\tsuper(options);\n\n\t\tlet storage = new Map();\n\t\t\n\t\tlet superNode = new SuperNode({ fs: this });\n\t\tstorage.set(superNode.id, superNode);\n\n\t\tlet rootNode = new Node({ fs: this, data: { mode: MODE_DIRECTORY } });\n\t\tstorage.set(rootNode.id, rootNode);\n\n\t\tsuperNode.rnode = rootNode.id;\t\t\n\n\t\t__.set(this, {\n\t\t\tstorage: storage,\n\t\t});\n\t}\n\n\tstatic get type()\n\t{\n\t\treturn \"memfs\";\n\t}\n\n\tstatic async mount(dev=UUID.short(), flags=[], options={})\n\t{\n\t\tlet fs = new MemFS();\n\n\t\treturn fs;\n\t}\n\n\tasync umount()\n\t{\n\t\tsuper.umount();\n\t}\n\n\tasync readNode(id)\n\t{\n\t\tlet node = __.get(this).storage.get(id);\n\n\t\tif(!node) {\n\t\t\tthrow new E.ENOENT();\n\t\t}\n\n\t\treturn node;\n\t}\n\n\tasync writeNode(id, node)\n\t{\n\t\t__.get(this).storage.set(id, node);\n\t}\n\n\tasync readData(id, block=0)\n\t{\n\t\tlet data = __.get(this).storage.get(`${id}${DATA_BLOCK_SEPARATOR}${block}`);\n\n\t\tif(!data) {\n\t\t\tthrow new E.EIO();\n\t\t}\n\n\t\treturn data;\n\t}\n\n\tasync writeData(id, block, data)\n\t{\n\t\t__.get(this).storage.set(`${id}${DATA_BLOCK_SEPARATOR}${block}`, data);\n\t}\n\n\tasync fsync()\n\t{\n\n\t}\n\n\tasync validate(id)\n\t{\n\n\t}\n}\n\nexport default MemFS;","import RootFS from \"./root-fs\";\nimport MemFS from \"./mem-fs\";\n\nexport default {\n\t[RootFS.type]: RootFS,\n\t[MemFS.type]: MemFS,\n};","import { MODE_FILE } from \"../common/constants\";\n\nconst __ = new WeakMap();\n\nclass DirectoryEntry\n{\n\tconstructor({ id, type=MODE_FILE } = {})\n\t{\n\t\t__.set(this, {\n\t\t\tid: id,\n\t\t\ttype: type,\n\t\t});\n\t}\n\n\tget id() { return __.get(this).id }\n\n\tget type() { return __.get(this).type }\n}\n\nexport default DirectoryEntry;","const __ = new WeakMap();\n\nconst URL_REGEX = /^((\\w+)\\+(\\w+):)?(\\/\\/((\\w+)?(:(\\w+))?@)?([^\\/\\?:]+)(:(\\d+))?)?(\\/?([^\\/\\?#][^\\?#]*)?)?(\\?([^#]+))?(#(\\w*))?/i;\n\nclass URL\n{\n\tconstructor(urlString)\n\t{\n\t\t__.set(this, {\n\n\t\t});\n\t\tconst self = __.get(this);\n\n\t    let match = urlString.match(URL_REGEX);\n\t \n\t \tself.originalURL = match[0];\n\n\t \tif(match[2]) {\n\t \t\tself.protocol = match[2];\n\t \t}\n\n\t    if(match[3]) {\n\t        self.subprotocol = match[3];\n\t    }\n\t \n\t    if(match[6]) {\n\t        self.username = match[6];\n\t    }\n\t \n\t    if(match[8]) {\n\t        self.password = match[8];\n\t    }\n\t \n\t    if(match[9]) {\n\t        self.host = match[9];\n\t    } else {\n\t    \tself.host = \"\";\n\t    }\n\t \n\t    if(match[11]) {\n\t        self.port = match[11];\n\t    }\n\n\t    if(match[12]) {\n\t    \tself.path = match[12];\n\t    } else {\n\t    \tself.path = \"\";\n\t    }\n\n\t    if(match[15]) {\n\t    \tlet queryList = match[15].split(\"&\");\n\t    \tlet query = {};\n\t    \tfor(let item of queryList) {\n\t    \t\tlet [key, value] = item.split(\"=\");\n\t    \t\tif(!(query.hasOwnProperty(key))) {\n\t    \t\t\tquery[key] = [];\n\t    \t\t}\n\t    \t\tif(value) {\n\t    \t\t\tquery[key].push(value);\n\t    \t\t}\n\t    \t}\n\t    \tself.query = query;\n\t    } else {\n\t    \tself.query = {};\n\t    }\n\n\t    if(match[17]) {\n\t    \tself.fragment = match[17];\n\t    } else {\n\t    \tself.fragment = \"\";\n\t    }\n\t}\n\n\tget protocol() { return __.get(this).protocol }\n\tset protocol(value) { return __.get(this).protocol = value }\n\n\tget subprotocol() { return __.get(this).subprotocol }\n\tset subprotocol(value) { return __.get(this).subprotocol = value }\n\n\tget username() { return __.get(this).username }\n\tset username(value) { return __.get(this).username = value }\n\n\tget password() { return __.get(this).password }\n\tset password(value) { return __.get(this).password = value }\n\n\tget host() { return __.get(this).host }\n\tset host(value) { return __.get(this).host = value }\n\n\tget port() { return __.get(this).port }\n\tset port(value) { return __.get(this).port = value }\n\n\tget path() { return __.get(this).path }\n\tset path(value) { return __.get(this).path = value }\n\n\tget query() { return __.get(this).query }\n\tset query(value) { return __.get(this).query = value }\n\n\tget fragment() { return __.get(this).fragment }\n\tset fragment(value) { return __.get(this).fragment = value }\n\n\ttoJSON()\n\t{\n\t\treturn {\n\t\t\tprotocol: this.protocol,\n\t\t\tsubprotocol: this.subprotocol,\n\t\t\tusername: this.username,\n\t\t\tpassword: this.password,\n\t\t\thost: this.host,\n\t\t\tport: this.port,\t\t\t\n\t\t\tpath: this.path,\n\t\t\tquery: this.query,\n\t\t\tfragment: this.fragment,\n\t\t};\n\t}\n}\n\nexport default URL;","import FDMap from \"./fdmap\";\nimport VFSMount from \"./vfsmount\";\nimport RootFS from \"../fs/providers/root-fs\";\nimport { check as pathCheck, normalize, basename, dirname } from \"../common/path\";\nimport { ROOT_DIRECTORY_NAME } from \"../common/constants\";\nimport Providers from \"../fs/providers/index\";\nimport E from \"../common/errors\";\nimport { SUPER_NODE_ID } from \"../common/constants\";\nimport { MNT_READ_ONLY } from \"../common/constants\";\nimport { SYMLOOP_MAX } from \"../common/constants\";\nimport { MODE_FILE, MODE_DIRECTORY, MODE_SYMBOLIC_LINK } from \"../common/constants\";\nimport UUID from \"../common/uuid\";\nimport DirectoryEntry from \"./directory-entry\";\nimport Node from \"../fs/node\";\nimport SuperNode from \"../fs/super-node\";\nimport URL from \"../common/url\";\n\nconst __ = new WeakMap();\n\nclass InternalVFS\n{\n\tconstructor()\n\t{\n\t\tconst rootFS = new RootFS();\n\t\tconst rootFSVFSMount = new VFSMount({ fs: rootFS, flags: [ MNT_READ_ONLY ] })\t\t\n\t\tconst fsVFSMounts = new WeakMap();\n\t\tfsVFSMounts.set(rootFS, rootFSVFSMount);\n\n\t\t__.set(this, {\n\t\t\tfdMap: new FDMap(),\n\n\t\t\tvfsMountsRoot: rootFSVFSMount,\n\t\t\tfsVFSMounts: fsVFSMounts,\n\t\t\tvfsMounts: new Map(),\n\t\t});\n\t}\n\n\tasync findNode({path, followSymlinks = true} = {}, context)\n\t{\n\t\tconst self = __.get(this);\n\n\t\tif(!context) {\n\t\t\tcontext = { symlinksFollowed: 0 };\n\t\t}\n\n\t\tpath = normalize(path);\n\t\tif(!path) {\n\t    \tthrow new E.ENOENT(\"path is an empty string\");\n\t  \t}\n\n\t\tlet name = basename(path);\n\t\tlet parentPath = dirname(path);\n\n\t\tlet fs;\n\t\tlet nodeId;\n\t\tif(ROOT_DIRECTORY_NAME == name) {\n\t\t\tfs = self.vfsMountsRoot.fs;\n\t\t\tlet superNode = await SuperNode.read(fs);\n\t\t\tnodeId = superNode.rnode;\n\t\t} else {\n\t\t\tlet parentDirectoryNode = await this.findNode({ path: parentPath }, context);\n\t\t\tfs = parentDirectoryNode.fs;\n\n\t\t\tif(parentDirectoryNode.mode !== MODE_DIRECTORY) {\n\t\t\t\tthrow new E.ENOTDIR(\"a component of the path prefix is not a directory\", path);\n\t\t\t}\n\n\t\t\tlet parentDirectoryData;\n\t\t\ttry {\n\t\t\t\tparentDirectoryData = await parentDirectoryNode.readData();\n\t\t\t} catch(error) {\n\t\t\t\tparentDirectoryData = new Object();\n\t\t\t}\n\n\t\t\tif(!parentDirectoryData.hasOwnProperty(name)) {\n\t\t\t\tthrow new E.ENOENT(null, path);\n\t\t\t}\n\n\t\t\tlet directoryEntry = new DirectoryEntry(parentDirectoryData[name]);\n\t\t\tnodeId = directoryEntry.id;\n\t\t}\n\n\t\t// Follow all vfsMounts on this node.\n\t\tlet nodeHash = Node.hash(fs, nodeId);\n\t\twhile(self.vfsMounts.has(nodeHash)) {\n\t\t\tlet vfsMount = (self.vfsMounts.get(nodeHash))[0];\n\t\t\tfs = vfsMount.fs;\n\n\t\t\tif(vfsMount.rnode) {\n\t\t\t\tnodeId = vfsMount.rnode;\n\t\t\t} else {\n\t\t\t\tlet superNode = await SuperNode.read(fs);\n\t\t\t\tnodeId = superNode.rnode;\n\t\t\t}\n\n\t\t\tnodeHash = Node.hash(fs, nodeId);\n\t\t}\t\t\n\n\t\tlet node = await Node.read(fs, nodeId);\n\n\t\tif(node.mode == MODE_SYMBOLIC_LINK) {\n\t\t\tcontext.symlinksFollowed += 1;\n\n\t\t\tif(context.symlinksFollowed > SYMLOOP_MAX) {\n\t\t\t\tthrow new E.ELOOP(null, path);\n\t\t\t}\n\n\t\t\tlet symlinkPath = await node.readData();\n\t\t\tnode = await this.findNode({ path: symlinkPath }, context);\n\t\t}\n\n\t\treturn node;\n\t}\n\n\tasync mount(fsURL, mountPath, flags, options)\n\t{\n\t\tconst self = __.get(this);\n\n\t\tlet mountPoint = await this.findNode({ path: mountPath });\n\n\t\tif(!mountPoint) {\n\t\t\tthrow new E.ENOENT(\"mount target does not exist\");\n\t\t}\n\n\t\tlet url = new URL(fsURL);\n\n\t\tif(\"filer\" !== url.protocol) {\n\t\t\tthrow new E.UNKNOWN(\"expecting filer protocol\");\n\t\t}\n\n\t\tlet dev = url.path.slice(1);\n\t\tlet type = url.subprotocol;\n\t\t\n\t\tif(!(type in Providers)) {\n\t\t\tthrow new E.UNKNOWN(\"unknown file system type\");\n\t\t}\n\n\t\tlet fs = await Providers[type].mount(dev, flags, options);\n\t\tlet superNode = await fs.readNode(SUPER_NODE_ID);\n\t\tlet rootNode = await fs.readNode(superNode.rnode);\n\n\t\tlet vfsMount = new VFSMount({ parent: self.fsVFSMounts.get(mountPoint.fs), flags: flags, fs: fs });\n\t\tself.fsVFSMounts.set(fs, vfsMount);\n\n\t\tif(!self.vfsMounts.has(mountPoint.hash())) {\n\t\t\tself.vfsMounts.set(mountPoint.hash(), new Array());\n\t\t}\n\t\tself.vfsMounts.get(mountPoint.hash()).unshift(vfsMount);\n\t}\n\n\tasync umount(path)\n\t{\n\t\tconst self = __.get(this);\n\n\t\tlet mountPoint = await this.findNode({ path: path });\nconsole.log(self.vfsMounts.keys(), mountPoint.hash());\n\t\tif(!self.vfsMounts.has(mountPoint.hash())) {\n\t\t\tthrow new E.EINVAL(null, path);\n\t\t}\n\n\t\tlet vfsMount = self.vfsMounts.get(mountPoint.hash());\n\t\tif(vfsMount.hasChildren()) {\n\t\t\tthrow new E.EBUSY(null, path);\n\t\t}\n\t}\n\n\topen(path, flags, mode, callback)\n\t{\n\n\t}\n\n\tclose(fd, callback)\n\t{\n\n\t}\n\n\tmknod(path, mode, callback)\n\t{\n\n\t}\n\n\tasync mkdir(path, mode)\n\t{\n\t\tpath = normalize(path);\n\n\t\tlet name = basename(path);\n\t\tlet parentPath = dirname(path);\n\n\t\tlet directoryNode;\n\t\ttry {\n\t\t\tdirectoryNode = await this.findNode({ path: path });\n\t\t} catch(error) {\n\t\t\tdirectoryNode = null;\n\t\t}\n\n\t\tif(directoryNode) {\n\t\t\tconsole.log(directoryNode.toJSON());\n\t\t\tthrow new E.EEXIST(null, path);\n\t\t}\n\n\t\tlet parentDirectoryNode = await this.findNode({ path: parentPath });\n\t\tlet fs = parentDirectoryNode.fs;\n\n\t\tlet parentDirectoryData\n\t\ttry {\n\t\t\tparentDirectoryData = await parentDirectoryNode.readData();\n\t\t} catch(error) {\n\t\t\tparentDirectoryData = new Object();\n\t\t}\n\n\t\tdirectoryNode = new Node({ fs: fs, data: { mode: MODE_DIRECTORY, nlinks: 1, data: UUID.short() } });\t\t\n\t\tdirectoryNode.write();\n\n\t\tlet directoryData = new Object();\n\t\tawait directoryNode.writeData(0, directoryData);\n\n\t\t// ! update node a/c/m times\n\n\t\tparentDirectoryData[name] = new DirectoryEntry({ id: directoryNode.id, type: MODE_DIRECTORY });\t\t\n\t\tawait parentDirectoryNode.writeData(0, parentDirectoryData);\n\n\t\tparentDirectoryNode.size = Object.keys(parentDirectoryData).length;\n\t\tawait parentDirectoryNode.write();\n\t}\n\n\tasync readdir(path)\n\t{\n\t\tpathCheck(path);\n\n\t\tlet directoryNode = await this.findNode({ path: path });\n\t\tlet directoryData;\n\t\ttry {\n\t\t\tdirectoryData = await directoryNode.readData();\n\t\t} catch(error) {\n\t\t\tif(error instanceof E.EIO)\n\t\t\t\tdirectoryData = new Object();\n\t\t}\n\n\t\tlet files = Object.keys(directoryData);\n\t\treturn files;\n\t}\n\n\trmdir(path, callback)\n\t{\n\n\t}\n\n\tstat(path, callback)\n\t{\n\n\t}\n\n\tfstat(fd, callback)\n\t{\n\n\t}\n\n\tlink(oldpath, newpath, callback)\n\t{\n\n\t}\n\n\tunlink(path, callback)\n\t{\n\n\t}\n\n\tread(fd, buffer, offset, length, position, callback)\n\t{\n\n\t}\n\n\treadFile(path, options, callback)\n\t{\n\n\t}\n\n\twrite(fd, buffer, offset, length, position, callback)\n\t{\n\n\t}\n\n\twriteFile(path, data, options, callback)\n\t{\n\n\t}\n\n\tappendFile(path, data, options, callback)\n\t{\n\n\t}\n\n\texists(path, callback)\n\t{\n\n\t}\n\n\tgetxattr(path, name, callback)\n\t{\n\n\t}\n\n\tfgetxattr(fd, name, callback)\n\t{\n\n\t}\n\n\tsetxattr(path, name, value, flag, callback)\n\t{\n\n\t}\n\n\tfsetxattr(fd, name, value, flag, callback)\n\t{\n\n\t}\n\n\tremovexattr(path, name, callback)\n\t{\n\n\t}\n\n\tfremovexattr(fd, name, callback)\n\t{\n\n\t}\n\n\tlseek(fd, offset, whence, callback)\n\t{\n\n\t}\t\n\n\tutimes(path, atime, mtime, callback)\n\t{\n\n\t}\n\n\tfutimes(fd, atime, mtime, callback)\n\t{\n\n\t}\n\n\trename(oldpath, newpath, callback)\n\t{\n\n\t}\n\n\tsymlink(srcpath, dstpath, type, callback)\n\t{\n\n\t}\n\n\treadlink(path, callback)\n\t{\n\n\t}\n\n\tlstat(path, callback)\n\t{\n\n\t}\n\n\ttruncate(path, length, callback)\n\t{\n\n\t}\n\n\tftruncate(fd, length, callback)\n\t{\n\n\t}\n};\n\nclass VFS\n{\n\tconstructor()\n\t{\n\t\t__.set(this, {\n\t\t\tvfs: new InternalVFS(),\n\t\t});\n\t}\n\n\tasync mount(...args) { return await __.get(this).vfs.mount(...args); }\n\n\tasync umount(...args) { return await __.get(this).vfs.umount(...args); }\n\n\tasync mkdir(...args) { return await __.get(this).vfs.mkdir(...args); }\n\n\tasync readdir(...args) { return await __.get(this).vfs.readdir(...args); }\n}\n\nexport default VFS;","import FS from \"./fs/index\";\nimport VFS from \"./vfs/index\";\nimport Providers from \"./fs/providers/index\";\nimport UUID from \"./common/uuid\";\nimport FilerBuffer from \"./common/buffer\";\nimport Crypto from \"./common/crypto\";\nimport URL from \"./common/url\";\n\nexport default { \n\tFS: FS,\n\tVFS: VFS,\n\tUUID: UUID,\n\tBuffer: FilerBuffer,\n\tCrypto: Crypto,\n};"],"names":["E","Crypto","__","pathCheck","FilerBuffer"],"mappings":"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"} diff --git a/package-lock.json b/package-lock.json new file mode 100644 index 0000000..c99150d --- /dev/null +++ b/package-lock.json @@ -0,0 +1,459 @@ +{ + "name": "filer", + "version": "1.0.0", + "lockfileVersion": 1, + "requires": true, + "dependencies": { + "@babel/code-frame": { + "version": "7.0.0-beta.49", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.0.0-beta.49.tgz", + "integrity": "sha1-vs2AVIJzREDJ0TfkbXc0DmTX9Rs=", + "dev": true, + "requires": { + "@babel/highlight": "7.0.0-beta.49" + } + }, + "@babel/highlight": { + "version": "7.0.0-beta.49", + "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.0.0-beta.49.tgz", + "integrity": "sha1-lr3GtD4TSCASumaRsQGEktOWIsw=", + "dev": true, + "requires": { + "chalk": "^2.0.0", + "esutils": "^2.0.2", + "js-tokens": "^3.0.0" + } + }, + "@types/estree": { + "version": "0.0.39", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-0.0.39.tgz", + "integrity": "sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==", + "dev": true + }, + "@types/node": { + "version": "10.3.0", + "resolved": "https://registry.npmjs.org/@types/node/-/node-10.3.0.tgz", + "integrity": "sha512-hWzNviaVFIr1TqcRA8ou49JaSHp+Rfabmnqg2kNvusKqLhPU0rIsGPUj5WJJ7ld4Bb7qdgLmIhLfCD1qS08IVA==", + "dev": true + }, + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "requires": { + "color-convert": "^1.9.0" + } + }, + "balanced-match": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz", + "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=" + }, + "base-x": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/base-x/-/base-x-1.1.0.tgz", + "integrity": "sha1-QtPXF0dPnqAiB/bRqh9CaRPut6w=" + }, + "base64-arraybuffer": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/base64-arraybuffer/-/base64-arraybuffer-0.1.5.tgz", + "integrity": "sha1-c5JncZI7Whl0etZmqlzUv5xunOg=" + }, + "base64-js": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.3.0.tgz", + "integrity": "sha512-ccav/yGvoa80BQDljCxsmmQ3Xvx60/UpBIij5QN21W3wBi/hhIC9OoO+KLpu9IJTS9j4DRVJ3aDDF9cMSoa2lw==" + }, + "brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "requires": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "browser-stdout": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/browser-stdout/-/browser-stdout-1.3.1.tgz", + "integrity": "sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==" + }, + "buffer": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.1.0.tgz", + "integrity": "sha512-YkIRgwsZwJWTnyQrsBTWefizHh+8GYj3kbL1BTiAQ/9pwpino0G7B2gp5tx/FUBqUlvtxV85KNR3mwfAtv15Yw==", + "requires": { + "base64-js": "^1.0.2", + "ieee754": "^1.1.4" + } + }, + "buffer-from": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.0.tgz", + "integrity": "sha512-c5mRlguI/Pe2dSZmpER62rSCu0ryKmWddzRYsuXc50U2/g8jMOulc31VZMa4mYx31U5xsmSOpDCgH88Vl9cDGQ==" + }, + "builtin-modules": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/builtin-modules/-/builtin-modules-2.0.0.tgz", + "integrity": "sha512-3U5kUA5VPsRUA3nofm/BXX7GVHKfxz0hOBAPxXrIvHzlDRkQVqEn6yi8QJegxl4LzOHLdvb7XF5dVawa/VVYBg==", + "dev": true + }, + "chalk": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.1.tgz", + "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", + "dev": true, + "requires": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + } + }, + "color-convert": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.1.tgz", + "integrity": "sha512-mjGanIiwQJskCC18rPR6OmrZ6fm2Lc7PeGFYwCmy5J34wC6F1PzdGL6xeMfmgicfYcNLGuVFA3WzXtIDCQSZxQ==", + "dev": true, + "requires": { + "color-name": "^1.1.1" + } + }, + "color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=", + "dev": true + }, + "commander": { + "version": "2.15.1", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.15.1.tgz", + "integrity": "sha512-VlfT9F3V0v+jr4yxPc5gg9s62/fIVWsd2Bk2iD435um1NlGMYdVCq+MjcXnhYq2icNOizHr1kK+5TI6H0Hy0ag==" + }, + "concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=" + }, + "debug": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz", + "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==", + "requires": { + "ms": "2.0.0" + } + }, + "diff": { + "version": "3.5.0", + "resolved": "https://registry.npmjs.org/diff/-/diff-3.5.0.tgz", + "integrity": "sha512-A46qtFgd+g7pDZinpnwiRJtxbC1hpgf0uzP3iG89scHk0AUC7A1TGxf5OiiOUv/JMZR8GOt8hL900hV0bOy5xA==" + }, + "escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=" + }, + "esutils": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.2.tgz", + "integrity": "sha1-Cr9PHKpbyx96nYrMbepPqqBLrJs=", + "dev": true + }, + "fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=" + }, + "glob": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.2.tgz", + "integrity": "sha512-MJTUg1kjuLeQCJ+ccE4Vpa6kKVXkPYJ2mOCQyUuKLcLQsdrMCpBPUi8qVE6+YuaJkozeA9NusTAw3hLr8Xe5EQ==", + "requires": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.4", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + } + }, + "growl": { + "version": "1.10.5", + "resolved": "https://registry.npmjs.org/growl/-/growl-1.10.5.tgz", + "integrity": "sha512-qBr4OuELkhPenW6goKVXiv47US3clb3/IbuWF9KNKEijAy9oeHxU9IgzjvJhHkUzhaj7rOUD7+YGWqUjLp5oSA==" + }, + "has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=" + }, + "he": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/he/-/he-1.1.1.tgz", + "integrity": "sha1-k0EP0hsAlzUVH4howvJx80J+I/0=" + }, + "ieee754": { + "version": "1.1.12", + "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.1.12.tgz", + "integrity": "sha512-GguP+DRY+pJ3soyIiGPTvdiVXjZ+DbXOxGpXn3eMvNW4x4irjqXm4wHKscC+TfxSJ0yw/S1F24tqdMNsMZTiLA==" + }, + "inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=", + "requires": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "inherits": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz", + "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=" + }, + "is-module": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-module/-/is-module-1.0.0.tgz", + "integrity": "sha1-Mlj7afeMFNW4FdZkM2tM/7ZEFZE=", + "dev": true + }, + "js-tokens": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-3.0.2.tgz", + "integrity": "sha1-mGbfOVECEw449/mWvOtlRDIJwls=", + "dev": true + }, + "minimatch": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz", + "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==", + "requires": { + "brace-expansion": "^1.1.7" + } + }, + "minimist": { + "version": "0.0.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz", + "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=" + }, + "mkdirp": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz", + "integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=", + "requires": { + "minimist": "0.0.8" + } + }, + "mocha": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/mocha/-/mocha-5.2.0.tgz", + "integrity": "sha512-2IUgKDhc3J7Uug+FxMXuqIyYzH7gJjXECKe/w43IGgQHTSj3InJi+yAA7T24L9bQMRKiUEHxEX37G5JpVUGLcQ==", + "requires": { + "browser-stdout": "1.3.1", + "commander": "2.15.1", + "debug": "3.1.0", + "diff": "3.5.0", + "escape-string-regexp": "1.0.5", + "glob": "7.1.2", + "growl": "1.10.5", + "he": "1.1.1", + "minimatch": "3.0.4", + "mkdirp": "0.5.1", + "supports-color": "5.4.0" + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=" + }, + "node-uuid": { + "version": "1.4.8", + "resolved": "https://registry.npmjs.org/node-uuid/-/node-uuid-1.4.8.tgz", + "integrity": "sha1-sEDrCSOWivq/jTL7HxfxFn/auQc=" + }, + "once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=", + "requires": { + "wrappy": "1" + } + }, + "path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=" + }, + "path-parse": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.5.tgz", + "integrity": "sha1-PBrfhx6pzWyUMbbqK9dKD/BVxME=", + "dev": true + }, + "querystringify": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/querystringify/-/querystringify-2.0.0.tgz", + "integrity": "sha512-eTPo5t/4bgaMNZxyjWx6N2a6AuE0mq51KWvpc7nU/MAqixcI6v6KrGUKES0HaomdnolQBBXU/++X6/QQ9KL4tw==" + }, + "requires-port": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/requires-port/-/requires-port-1.0.0.tgz", + "integrity": "sha1-kl0mAdOaxIXgkc8NpcbmlNw9yv8=" + }, + "resolve": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.8.1.tgz", + "integrity": "sha512-AicPrAC7Qu1JxPCZ9ZgCZlY35QgFnNqc+0LtbRNxnVw4TXvjQ72wnuL9JQcEBgXkI9JM8MsT9kaQoHcpCRJOYA==", + "dev": true, + "requires": { + "path-parse": "^1.0.5" + } + }, + "rollup": { + "version": "0.59.4", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-0.59.4.tgz", + "integrity": "sha512-ISiMqq/aJa+57QxX2MRcvLESHdJ7wSavmr6U1euMr+6UgFe6KM+3QANrYy8LQofwhTC1I7BcAdlLnDiaODs1BA==", + "dev": true, + "requires": { + "@types/estree": "0.0.39", + "@types/node": "*" + } + }, + "rollup-plugin-node-resolve": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/rollup-plugin-node-resolve/-/rollup-plugin-node-resolve-3.3.0.tgz", + "integrity": "sha512-9zHGr3oUJq6G+X0oRMYlzid9fXicBdiydhwGChdyeNRGPcN/majtegApRKHLR5drboUvEWU+QeUmGTyEZQs3WA==", + "dev": true, + "requires": { + "builtin-modules": "^2.0.0", + "is-module": "^1.0.0", + "resolve": "^1.1.6" + } + }, + "rollup-plugin-uglify": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/rollup-plugin-uglify/-/rollup-plugin-uglify-4.0.0.tgz", + "integrity": "sha512-f6W31EQLzxSEYfN3x6/lyljHqXSoCjXKcTsnwz3evQvHgU1+qTzU2SE0SIG7tbAvaCewp2UaZ5x3k6nYsxOP9A==", + "dev": true, + "requires": { + "@babel/code-frame": "^7.0.0-beta.47", + "uglify-js": "^3.3.25" + } + }, + "semver": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.5.0.tgz", + "integrity": "sha512-4SJ3dm0WAwWy/NVeioZh5AntkdJoWKxHxcmyP622fOkgHa4z3R0TdBJICINyaSDE6uNwVc8gZr+ZinwZAH4xIA==", + "dev": true + }, + "should": { + "version": "13.2.1", + "resolved": "https://registry.npmjs.org/should/-/should-13.2.1.tgz", + "integrity": "sha512-l+/NwEMO+DcstsHEwPHRHzC9j4UOE3VQwJGcMWSsD/vqpqHbnQ+1iSHy64Ihmmjx1uiRPD9pFadTSc3MJtXAgw==", + "requires": { + "should-equal": "^2.0.0", + "should-format": "^3.0.3", + "should-type": "^1.4.0", + "should-type-adaptors": "^1.0.1", + "should-util": "^1.0.0" + } + }, + "should-equal": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/should-equal/-/should-equal-2.0.0.tgz", + "integrity": "sha512-ZP36TMrK9euEuWQYBig9W55WPC7uo37qzAEmbjHz4gfyuXrEUgF8cUvQVO+w+d3OMfPvSRQJ22lSm8MQJ43LTA==", + "requires": { + "should-type": "^1.4.0" + } + }, + "should-format": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/should-format/-/should-format-3.0.3.tgz", + "integrity": "sha1-m/yPdPo5IFxT04w01xcwPidxJPE=", + "requires": { + "should-type": "^1.3.0", + "should-type-adaptors": "^1.0.1" + } + }, + "should-type": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/should-type/-/should-type-1.4.0.tgz", + "integrity": "sha1-B1bYzoRt/QmEOmlHcZ36DUz/XPM=" + }, + "should-type-adaptors": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/should-type-adaptors/-/should-type-adaptors-1.1.0.tgz", + "integrity": "sha512-JA4hdoLnN+kebEp2Vs8eBe9g7uy0zbRo+RMcU0EsNy+R+k049Ki+N5tT5Jagst2g7EAja+euFuoXFCa8vIklfA==", + "requires": { + "should-type": "^1.3.0", + "should-util": "^1.0.0" + } + }, + "should-util": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/should-util/-/should-util-1.0.0.tgz", + "integrity": "sha1-yYzaN0qmsZDfi6h8mInCtNtiAGM=" + }, + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==" + }, + "source-map-support": { + "version": "0.5.6", + "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.6.tgz", + "integrity": "sha512-N4KXEz7jcKqPf2b2vZF11lQIz9W5ZMuUcIOGj243lduidkf2fjkVKJS9vNxVWn3u/uxX38AcE8U9nnH9FPcq+g==", + "requires": { + "buffer-from": "^1.0.0", + "source-map": "^0.6.0" + } + }, + "supports-color": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.4.0.tgz", + "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", + "requires": { + "has-flag": "^3.0.0" + } + }, + "uglify-js": { + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.4.0.tgz", + "integrity": "sha512-Jcf5naPkX3rVPSQpRn9Vm6Rr572I1gTtR9LnqKgXjmOgfYQ/QS0V2WRStFR53Bdj520M66aCZqt9uzYXgtGrJQ==", + "dev": true, + "requires": { + "commander": "~2.15.0", + "source-map": "~0.6.1" + } + }, + "url-parse": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/url-parse/-/url-parse-1.4.1.tgz", + "integrity": "sha512-x95Td74QcvICAA0+qERaVkRpTGKyBHHYdwL2LXZm5t/gBtCB9KQSO/0zQgSTYEV1p0WcvSg79TLNPSvd5IDJMQ==", + "requires": { + "querystringify": "^2.0.0", + "requires-port": "^1.0.0" + } + }, + "uuid-base62": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/uuid-base62/-/uuid-base62-0.1.0.tgz", + "integrity": "sha1-oqhTuYvguq7k917kG8PY5aFcD34=", + "requires": { + "base-x": "^1.0.0", + "node-uuid": "^1.4.3" + } + }, + "uuid-parse": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/uuid-parse/-/uuid-parse-1.0.0.tgz", + "integrity": "sha1-9GV3F2JLDkuIrzb5jYlYmlu+5Wk=" + }, + "wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=" + } + } +} diff --git a/package.json b/package.json new file mode 100644 index 0000000..2a74477 --- /dev/null +++ b/package.json @@ -0,0 +1,47 @@ +{ + "name": "filer", + "description": "Node-like file system for browsers", + "keywords": [ + "fs", + "node", + "file", + "system", + "browser", + "indexeddb", + "idb", + "websql" + ], + "version": "1.0.0", + "author": "Alan K (http://blog.modeswitch.org)", + "homepage": "http://filerjs.github.io/filer", + "bugs": "https://github.com/filerjs/filer/issues", + "license": "BSD", + "scripts": { + "build": "rollup -c --environment=development", + "test": "node node_modules/mocha/bin/mocha test/" + }, + "repository": { + "type": "git", + "url": "https://github.com/filerjs/filer.git" + }, + "dependencies": { + "base64-arraybuffer": "^0.1.2", + "buffer": "^5.1.0", + "debug": "^3.1.0", + "minimatch": "^3.0.4", + "mocha": "^5.2.0", + "should": "^13.2.1", + "source-map-support": "^0.5.6", + "url-parse": "^1.4.1", + "uuid-base62": "^0.1.0", + "uuid-parse": "^1.0.0" + }, + "devDependencies": { + "rollup": "^0.59.4", + "rollup-plugin-node-resolve": "^3.3.0", + "rollup-plugin-uglify": "^4.0.0", + "semver": "^5.5.0" + }, + "main": "dist/filer.js", + "module": "src/index.js" +} diff --git a/rollup.config.js b/rollup.config.js new file mode 100644 index 0000000..4633143 --- /dev/null +++ b/rollup.config.js @@ -0,0 +1,13 @@ +// import pkg from "./package.json"; + +export default [ + { + input: "src/index.js", + output: { + name: "Filer", + file: "dist/filer.js", + format: "umd", + sourcemap: "inline", + }, + }, +]; diff --git a/src/common/buffer.js b/src/common/buffer.js new file mode 100644 index 0000000..e23be60 --- /dev/null +++ b/src/common/buffer.js @@ -0,0 +1,76 @@ +const INSPECT_MAX_BYTES = 50; +const K_MAX_LENGTH = 0x7fffffff; + +class Buffer extends Uint8Array +{ + constructor(arg, encodingOrOffset, length) + { + if (typeof arg === "number") { + if (typeof encodingOrOffset === "string") { + throw new TypeError(`The "string" argument must be of type string. Received type number`); + } + return allocUnsafe(arg); + } + return from(arg, encodingOrOffset, length); + } + + static get INSPECT_MAX_BYTES() { return 50 } + + static get K_MAX_LENGTH() { return 0x7fffffff } + + static isSupported() + { + try { + var arr = new Uint8Array(1) + arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }} + return arr.foo() === 42 + } catch (e) { + return false + } + } + + static from(value, encodingOrOffset, length) + { + if (typeof value === 'string') { + return fromString(value, encodingOrOffset) + } + + if (ArrayBuffer.isView(value)) { + return fromArrayLike(value) + } + + if (value == null) { + throw TypeError(`The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type ${typeof value}`); + } + + if (isInstance(value, ArrayBuffer) || + (value && isInstance(value.buffer, ArrayBuffer))) { + return fromArrayBuffer(value, encodingOrOffset, length) + } + + if (typeof value === 'number') { + throw new TypeError( + 'The "value" argument must not be of type number. Received type number' + ) + } + + var valueOf = value.valueOf && value.valueOf(); + if(valueOf != null && valueOf !== value) { + return Buffer.from(valueOf, encodingOrOffset, length); + } + + var b = fromObject(value); + if(b) { + return b; + } + + if(typeof Symbol !== "undefined" && Symbol.toPrimitive != null && + typeof value[Symbol.toPrimitive] === "function") { + return Buffer.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length); + } + + throw new TypeError(`The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type ${typeof value}`); + } +} + +export default Buffer; \ No newline at end of file diff --git a/src/common/constants.js b/src/common/constants.js new file mode 100644 index 0000000..7e6ebbf --- /dev/null +++ b/src/common/constants.js @@ -0,0 +1,28 @@ +import Buffer from "./buffer"; + +export const SUPER_NODE_ID = "0000000000000000000000"; + +export const MODE_FILE = "FILE"; +export const MODE_DIRECTORY = "DIRECTORY"; +export const MODE_SYMBOLIC_LINK = "MODE_SYMBOLIC_LINK"; +export const MODE_META = "META"; +export const MODE_SOCKET = "SOCKET"; +export const MODE_FIFO = "FIFO"; +export const MODE_CHARACTER_DEVICE = "CHARACTER_DEVICE"; +export const MODE_BLOCK_DEVICE = "BLOCK_DEVICE"; + +export const ROOT_DIRECTORY_NAME = "/"; // basename(normalize(path)) + +export const STDIN = 0; +export const STDOUT = 1; +export const STDERR = 2; + +export const FIRST_DESCRIPTOR = 3; + +export const N_VFS_DESCRIPTORS = 1024; + +export const DATA_BLOCK_SEPARATOR = "#"; + +export const MNT_READ_ONLY = "READ_ONLY"; + +export const SYMLOOP_MAX = 10; \ No newline at end of file diff --git a/src/common/crypto.js b/src/common/crypto.js new file mode 100644 index 0000000..72e38c2 --- /dev/null +++ b/src/common/crypto.js @@ -0,0 +1,26 @@ +import Platform from "./platform"; +import E from "./errors"; + +let Crypto; +if(Platform.supportsWebCrypto()) { + Crypto = class Crypto + { + static randomBytes(arrayBuffer) + { + return window.crypto.getRandomValues(arrayBuffer); + } + } +} else if(Platform.supportsNodeCrypto()) { + let nodeCrypto = require("crypto"); + Crypto = class Crypto + { + static randomBytes(arrayBuffer) + { + return nodeCrypto.randomFillSync(arrayBuffer); + } + } +} else { + throw new E.ENOTSUPPORTED("crypto support is not available on this platform"); +} + +export default Crypto; \ No newline at end of file diff --git a/src/common/errors.js b/src/common/errors.js new file mode 100644 index 0000000..f32efc3 --- /dev/null +++ b/src/common/errors.js @@ -0,0 +1,68 @@ +class FilerError extends Error +{ + constructor(message, path = null) + { + super(message); + + this.path = path; + } +} + +const errors = {}; +const errorDefinitions = +[ + { errno: -1, name: "UNKNOWN", text: "unknown error" }, + { errno: 0, name: "OK", text: "success" }, + { errno: 1, name: "EOF", text: "end of file" }, + + { errno: 9, name: "EBADF", text: "bad file descriptor" }, + { errno: 10, name: "EBUSY", text: "resource busy or locked" }, + + { errno: 18, name: "EINVAL", text: "invalid argument" }, + + { errno: 27, name: "ENOTDIR", text: "not a directory" }, + { errno: 28, name: "EISDIR", text: "illegal operation on directory" }, + + { errno: 34, name: "ENOENT", text: "no such file or directory" }, + + { errno: 47, name: "EEXIST", text: "file already exists" }, + + { errno: 50, name: "EPERM", text: "operation not permitted" }, + { errno: 51, name: "ELOOP", text: "too many symbolic links encountered" }, + + { errno: 53, name: "ENOTEMPTY", text: "directory not empty" }, + + { errno: 55, name: "EIO", text: "i/o error" }, + { errno: 56, name: "EROFS", text: "read-only file system" }, + { errno: 57, name: "ENODEV", text: "no such device" }, + + { errno: 58, name: "ECANCELED", text: "operation canceled" }, + + { errno: 1000, name: "ENOTSUPPORTED", text: "platform is not supported" }, +] + +for (let error of errorDefinitions) { + errors[error.errno] = errors[error.name] = class extends FilerError { + constructor(message, path) + { + super(message || error.text, path); + } + + get name() { return error.name } + + get code() { return error.name } + + get errno() { return error.errno } + + get message() { return this.message } + + get stack() { return (new Error(this.message)).stack } + + get toString() { + pathInfo = this.path ? (', \'' + this.path + '\'') : ''; + return `${this.name}: ${this.message}${pathInfo}`; + } + } +} + +export default errors; \ No newline at end of file diff --git a/src/common/index.js b/src/common/index.js new file mode 100644 index 0000000..e69de29 diff --git a/src/common/path.js b/src/common/path.js new file mode 100644 index 0000000..d166496 --- /dev/null +++ b/src/common/path.js @@ -0,0 +1,204 @@ +import E from "./errors"; + +function normalizeArray(parts, allowAboveRoot) { + // if the path tries to go above the root, `up` ends up > 0 + var up = 0; + for (var i = parts.length - 1; i >= 0; i--) { + var last = parts[i]; + if (last === '.') { + parts.splice(i, 1); + } else if (last === '..') { + parts.splice(i, 1); + up++; + } else if (up) { + parts.splice(i, 1); + up--; + } + } + + // if the path is allowed to go above the root, restore leading ..s + if (allowAboveRoot) { + for (; up--; up) { + parts.unshift('..'); + } + } + + return parts; +} + +// Split a filename into [root, dir, basename, ext], unix version +// 'root' is just a slash, or nothing. +var splitPathRe = + /^(\/?)([\s\S]+\/(?!$)|\/)?((?:\.{1,2}$|[\s\S]+?)?(\.[^.\/]*)?)$/; +var splitPath = function(filename) { + var result = splitPathRe.exec(filename); + return [result[1] || '', result[2] || '', result[3] || '', result[4] || '']; +}; + +// path.resolve([from ...], to) +export function resolve() { + var resolvedPath = '', + resolvedAbsolute = false; + + for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) { + // XXXfiler: we don't have process.cwd() so we use '/' as a fallback + var path = (i >= 0) ? arguments[i] : '/'; + + // Skip empty and invalid entries + if (typeof path !== 'string' || !path) { + continue; + } + + resolvedPath = path + '/' + resolvedPath; + resolvedAbsolute = path.charAt(0) === '/'; + } + + // At this point the path should be resolved to a full absolute path, but + // handle relative paths to be safe (might happen when process.cwd() fails) + + // Normalize the path + resolvedPath = normalizeArray(resolvedPath.split('/').filter(function(p) { + return !!p; + }), !resolvedAbsolute).join('/'); + + return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.'; +} + +// path.normalize(path) +export function normalize(path) { + var isAbsolute = path.charAt(0) === '/', + trailingSlash = path.substr(-1) === '/'; + + // Normalize the path + path = normalizeArray(path.split('/').filter(function(p) { + return !!p; + }), !isAbsolute).join('/'); + + if (!path && !isAbsolute) { + path = '.'; + } + /* + if (path && trailingSlash) { + path += '/'; + } + */ + + return (isAbsolute ? '/' : '') + path; +} + +export function join() { + var paths = Array.prototype.slice.call(arguments, 0); + return normalize(paths.filter(function(p, index) { + return p && typeof p === 'string'; + }).join('/')); +} + +// path.relative(from, to) +export function relative(from, to) { + from = resolve(from).substr(1); + to = resolve(to).substr(1); + + function trim(arr) { + var start = 0; + for (; start < arr.length; start++) { + if (arr[start] !== '') break; + } + + var end = arr.length - 1; + for (; end >= 0; end--) { + if (arr[end] !== '') break; + } + + if (start > end) return []; + return arr.slice(start, end - start + 1); + } + + var fromParts = trim(from.split('/')); + var toParts = trim(to.split('/')); + + var length = Math.min(fromParts.length, toParts.length); + var samePartsLength = length; + for (var i = 0; i < length; i++) { + if (fromParts[i] !== toParts[i]) { + samePartsLength = i; + break; + } + } + + var outputParts = []; + for (var i = samePartsLength; i < fromParts.length; i++) { + outputParts.push('..'); + } + + outputParts = outputParts.concat(toParts.slice(samePartsLength)); + + return outputParts.join('/'); +} + +export function dirname(path) { + var result = splitPath(path), + root = result[0], + dir = result[1]; + + if (!root && !dir) { + // No dirname whatsoever + return '.'; + } + + if (dir) { + // It has a dirname, strip trailing slash + dir = dir.substr(0, dir.length - 1); + } + + return root + dir; +} + +export function basename(path, ext) { + var f = splitPath(path)[2]; + // TODO: make this comparison case-insensitive on windows? + if (ext && f.substr(-1 * ext.length) === ext) { + f = f.substr(0, f.length - ext.length); + } + // XXXfiler: node.js just does `return f` + return f === "" ? "/" : f; +} + +export function extname(path) { + return splitPath(path)[3]; +} + +export function isAbsolute(path) { + if(path.charAt(0) === '/') { + return true; + } + return false; +} + +export function isNull(path) { + if (('' + path).indexOf('\u0000') !== -1) { + return true; + } + return false; +} + +// Make sure we don't double-add a trailing slash (e.g., '/' -> '//') +export function addTrailing(path) { + return path.replace(/\/*$/, '/'); +} + +// Deal with multiple slashes at the end, one, or none +// and make sure we don't return the empty string. +export function removeTrailing(path) { + path = path.replace(/\/*$/, ''); + return path === '' ? '/' : path; +} + +export function check(path) { + if(!path) { + throw new E.EINVAL('path must be a string', path); + } else if(isNull(path)) { + throw new E.EINVAL('path must be a string without null bytes', path); + } else if(!isAbsolute(path)) { + throw new E.EINVAL('path must be absolute', path); + } +} \ No newline at end of file diff --git a/src/common/platform.js b/src/common/platform.js new file mode 100644 index 0000000..f18e1f6 --- /dev/null +++ b/src/common/platform.js @@ -0,0 +1,24 @@ +class Platform +{ + static supportsWebCrypto() + { + return ("undefined" !== typeof window && + "undefined" !== typeof window.crypto && + "function" === typeof window.crypto.getRandomValues); + } + + static supportsNodeCrypto() + { + if("undefined" !== typeof process) { + try { + require.resolve("crypto"); + return true; + } catch(e) { + } + } + + return false; + } +} + +export default Platform; \ No newline at end of file diff --git a/src/common/url.js b/src/common/url.js new file mode 100644 index 0000000..360ccc3 --- /dev/null +++ b/src/common/url.js @@ -0,0 +1,117 @@ +const __ = new WeakMap(); + +const URL_REGEX = /^((\w+)\+(\w+):)?(\/\/((\w+)?(:(\w+))?@)?([^\/\?:]+)(:(\d+))?)?(\/?([^\/\?#][^\?#]*)?)?(\?([^#]+))?(#(\w*))?/i; + +class URL +{ + constructor(urlString) + { + __.set(this, { + + }); + const self = __.get(this); + + let match = urlString.match(URL_REGEX); + + self.originalURL = match[0]; + + if(match[2]) { + self.protocol = match[2]; + } + + if(match[3]) { + self.subprotocol = match[3]; + } + + if(match[6]) { + self.username = match[6]; + } + + if(match[8]) { + self.password = match[8]; + } + + if(match[9]) { + self.host = match[9]; + } else { + self.host = ""; + } + + if(match[11]) { + self.port = match[11]; + } + + if(match[12]) { + self.path = match[12]; + } else { + self.path = ""; + } + + if(match[15]) { + let queryList = match[15].split("&"); + let query = {}; + for(let item of queryList) { + let [key, value] = item.split("="); + if(!(query.hasOwnProperty(key))) { + query[key] = []; + } + if(value) { + query[key].push(value); + } + } + self.query = query; + } else { + self.query = {}; + } + + if(match[17]) { + self.fragment = match[17]; + } else { + self.fragment = ""; + } + } + + get protocol() { return __.get(this).protocol } + set protocol(value) { return __.get(this).protocol = value } + + get subprotocol() { return __.get(this).subprotocol } + set subprotocol(value) { return __.get(this).subprotocol = value } + + get username() { return __.get(this).username } + set username(value) { return __.get(this).username = value } + + get password() { return __.get(this).password } + set password(value) { return __.get(this).password = value } + + get host() { return __.get(this).host } + set host(value) { return __.get(this).host = value } + + get port() { return __.get(this).port } + set port(value) { return __.get(this).port = value } + + get path() { return __.get(this).path } + set path(value) { return __.get(this).path = value } + + get query() { return __.get(this).query } + set query(value) { return __.get(this).query = value } + + get fragment() { return __.get(this).fragment } + set fragment(value) { return __.get(this).fragment = value } + + toJSON() + { + return { + protocol: this.protocol, + subprotocol: this.subprotocol, + username: this.username, + password: this.password, + host: this.host, + port: this.port, + path: this.path, + query: this.query, + fragment: this.fragment, + }; + } +} + +export default URL; \ No newline at end of file diff --git a/src/common/uuid.js b/src/common/uuid.js new file mode 100644 index 0000000..a2efb98 --- /dev/null +++ b/src/common/uuid.js @@ -0,0 +1,63 @@ +import Crypto from "./crypto"; + +const UUID_SHORT_REGEX = /^[0-9a-zA-Z]{22}$/; +const BASE = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".split(''); +const BASE_MAP = {}; + +for (var z = 0; z < BASE.length; z += 1) { + var x = BASE[z]; + + if (BASE_MAP[x] !== undefined) throw new TypeError(`${x} is ambiguous`) + BASE_MAP[x] = z; +} + +function encode(source) { + if (source.length === 0) return '' + + var digits = [0] + for (var i = 0; i < source.length; ++i) { + for (var j = 0, carry = source[i]; j < digits.length; ++j) { + carry += digits[j] << 8 + digits[j] = carry % BASE.length + carry = (carry / BASE.length) | 0 + } + + while (carry > 0) { + digits.push(carry % BASE.length) + carry = (carry / BASE.length) | 0 + } + } + + var string = ""; + + for (var k = 0; source[k] === 0 && k < source.length - 1; ++k) + string += BASE[0]; + + for (var q = digits.length - 1; q >= 0; --q) + string += BASE[digits[q]]; + + return string +} + +class UUID { + static v4() + { + let buffer = new Uint8Array(16); + Crypto.randomBytes(buffer); + + buffer[6] &= 0b00001111; + buffer[6] |= 0b01000000; + + buffer[8] &= 0b00111111; + buffer[8] |= 0b10000000; + + return encode(buffer); + } + + static short() + { + return this.v4(); + } +} + +export default UUID; \ No newline at end of file diff --git a/src/fs/file.js b/src/fs/file.js new file mode 100644 index 0000000..244f004 --- /dev/null +++ b/src/fs/file.js @@ -0,0 +1,29 @@ +const { EBADF } = require("../common/errors"); + +const __ = new WeakMap(); + +/* An open file. */ +class File +{ + constructor(path, id, flags, position) + { + __.set(this, { + path: path, + id: id, + flags: flags, + position: position, + }); + } + + read() + { + + } + + write() + { + + } +} + +export default File; \ No newline at end of file diff --git a/src/fs/fs.js b/src/fs/fs.js new file mode 100644 index 0000000..cd0313e --- /dev/null +++ b/src/fs/fs.js @@ -0,0 +1,40 @@ +import UUID from "../common/uuid"; + +const __ = new WeakMap(); + +class FS +{ + constructor(superNode, options) + { + let { proxy, revoke } = Proxy.revocable(this, {}); + + __.set(proxy, { + id: UUID.short(), // instance ID + revoke: revoke, + }); + + return proxy; + } + + get id() + { + return __.get(this).id; + } + + static async mount(dev, flags=[], options={}) + { + + } + + async umount() + { + __.get(this).revoke(); + } + + toString() + { + return this.id; + } +} + +export default FS; \ No newline at end of file diff --git a/src/fs/index.js b/src/fs/index.js new file mode 100644 index 0000000..303b6e1 --- /dev/null +++ b/src/fs/index.js @@ -0,0 +1,3 @@ +import FS from "./fs"; + +export default FS; \ No newline at end of file diff --git a/src/fs/node.js b/src/fs/node.js new file mode 100644 index 0000000..f02e530 --- /dev/null +++ b/src/fs/node.js @@ -0,0 +1,230 @@ +import UUID from "../common/uuid"; +import { MODE_FILE, MODE_DIRECTORY, MODE_SYMBOLIC_LINK } from "../common/constants"; +import Buffer from "../common/buffer"; +import E from "../common/errors"; + +const __ = new WeakMap(); + +class NodeData +{ + constructor({ mode, size = 0, atime, mtime, ctime, version = UUID.short(), flags, xattrs, nlinks, blksize, nblocks, blkid = UUID.short() }) + { + __.set(this, { + mode: mode, // node type (file, directory, etc) + size: size, + atime: atime || Date.now(), // access time (will mirror ctime after creation) + mtime: mtime || Date.now(), // creation/change time + ctime: ctime || Date.now(), // modified time + version: version || UUID.short(), + flags: flags || [], + xattrs: xattrs || {}, + nlinks: nlinks || 0, + blksize: blksize || 4096, + nblocks: nblocks || 0, + blkid: blkid, + }); + } + + get mode() { return __.get(this).mode } + + get atime() { return __.get(this).atime } + set atime(value) { return __.get(this).atime = value } + + get mtime() { return __.get(this).mtime } + set mtime(value) { return __.get(this).mtime = value } + + get ctime() { return __.get(this).ctime } + set ctime(value) { return __.get(this).ctime = value } + + get version() { return __.get(this).version } + set version(value) { return __.get(this).version = value } + + get flags() { return __.get(this).flags } + + get xattrs() { return __.get(this).xattrs } + + get nlinks() { return __.get(this).nlinks } + set nlinks(value) { return __.get(this).nlinks = value } + + get blksize() { return __.get(this).blksize } + + get nblocks() { return __.get(this).nblocks } + set nblocks(value) { return __.get(this).nblocks = value } + + get blkid() { return __.get(this).blkid } + set blkid(value) { return __.get(this).blkid = value } + + get size() { return __.get(this).size } + set size(value) { return __.get(this).size = value } + + toJSON() + { + return { + mode: this.mode, + size: this.size, + atime: this.atime, + mtime: this.mtime, + ctime: this.ctime, + nlinks: this.nlinks, + version: this.version, + blksize: this.blksize, + nblocks: this.nblocks, + blkid: this.blkid, + flags: this.flags, + xattrs: this.xattrs, + }; + } +} + +class Node +{ + constructor({ fs, id = UUID.short(), data } = {}) + { + __.set(this, { + fs: fs, + id: id, + + data: new NodeData(data), + }); + } + + get fs() { return __.get(this).fs } + + get id() { return __.get(this).id } + + get size() { return __.get(this).data.size } + set size(value) { return __.get(this).data.size = value } + + get nlinks() { return __.get(this).data.nlinks } + set nlinks(value) { return __.get(this).data.nlinks = value } + + get version() { return __.get(this).data.version } + set version(value) { return __.get(this).data.version = value } + + get blksize() { return __.get(this).data.blksize } + + get nblocks() { return __.get(this).data.nblocks } + set nblocks(value) { return __.get(this).data.nblocks = value } + + get atime() { return __.get(this).data.atime } + set atime(value) { return __.get(this).data.atime = value } + + get mtime() { return __.get(this).data.mtime } + set mtime(value) { return __.get(this).data.mtime = value } + + get ctime() { return __.get(this).data.ctime } + set ctime(value) { return __.get(this).data.ctime = value } + + get mode() { return __.get(this).data.mode } + + get blkid() { return __.get(this).data.blkid } + set blkid(value) { return __.get(this).data.blkid = value } + + get flags() { return __.get(this).data.flags } + + get xattrs() { return __.get(this).data.xattrs } + + get data() { return __.get(this).data.toJSON() } + + isFile() + { + return MODE_FILE == this.mode; + } + + isDirectory() + { + return MODE_DIRECTORY == this.mode; + } + + isSymbolicLink() + { + return MODE_SYMBOLIC_LINK == this.mode; + } + + isSocket() + { + return MODE_SOCKET == this.mode; + } + + isFIFO() + { + return MODE_FIFO == this.mode; + } + + isCharacterDevice() + { + return MODE_CHARACTER_DEVICE == this.mode; + } + + isBlockDevice() + { + return MODE_BLOCK_DEVICE == this.mode; + } + + toString() + { + return JSON.stringify(this.toJSON()); + } + + static hash(fs, id) + { + return `${fs.id}${id}`; + } + + hash() + { + return Node.hash(this.fs, this.id); + } + + static async read(fs, id) + { + let data = await fs.readNode(id); + return new Node({ fs: fs, id: id, data: data }); + } + + async read() + { + let data = await this.fs.readNode(this.id); + __.get(this).data = new NodeData(data); + } + + async write() + { + this.version = UUID.short(); + return await this.fs.writeNode(this.id, this.data); + } + + async readData(block=0) + { + let data = await this.fs.readData(this.blkid, block); + + return data; + } + + async writeData(block=0, data) + { + this.nblocks = block + 1; + await this.fs.writeData(this.blkid, block, data); + } + + async validate() + { + + } + + toJSON() + { + return { + fs: this.fs.id, + id: this.id, + data: __.get(this).data.toJSON(), + } + } + + toString() + { + return JSON.stringify(this.toJSON()); + } +} + +export default Node; \ No newline at end of file diff --git a/src/fs/providers/index.js b/src/fs/providers/index.js new file mode 100644 index 0000000..9963236 --- /dev/null +++ b/src/fs/providers/index.js @@ -0,0 +1,7 @@ +import RootFS from "./root-fs"; +import MemFS from "./mem-fs"; + +export default { + [RootFS.type]: RootFS, + [MemFS.type]: MemFS, +}; \ No newline at end of file diff --git a/src/fs/providers/indexeddb-fs.js b/src/fs/providers/indexeddb-fs.js new file mode 100644 index 0000000..27ed1f1 --- /dev/null +++ b/src/fs/providers/indexeddb-fs.js @@ -0,0 +1,58 @@ +import FS from "../index"; +import SuperNode from "../super-node"; +import Node from "../node"; +import UUID from "../../common/uuid"; +import E from "../../common/errors"; +import { MODE_FILE, MODE_DIRECTORY, DATA_BLOCK_SEPARATOR } from "../../common/constants"; +import Buffer from "../../common/buffer"; + +const __ = new WeakMap(); + +class IDBFS extends FS +{ + constructor(superNode, options={}) + { + + } + + static get type() + { + return "idbfs"; + } + + static async mount(dev=UUID.short(), flags=[], options={}) + { + + } + + async umount() + { + super.umount(); + } + + async readNode(id) + { + } + + async writeNode(id, node) + { + } + + async readData(id, block=0, mode=MODE_FILE) + { + } + + async writeData(id, block, data) + { + } + + async fsync() + { + } + + async validate(id) + { + } +} + +export default IDBFS; \ No newline at end of file diff --git a/src/fs/providers/mem-fs.js b/src/fs/providers/mem-fs.js new file mode 100644 index 0000000..2432579 --- /dev/null +++ b/src/fs/providers/mem-fs.js @@ -0,0 +1,92 @@ +import FS from "../index"; +import SuperNode from "../super-node"; +import Node from "../node"; +import UUID from "../../common/uuid"; +import E from "../../common/errors"; +import { MODE_FILE, MODE_DIRECTORY, DATA_BLOCK_SEPARATOR } from "../../common/constants"; +import Buffer from "../../common/buffer"; + +const __ = new WeakMap(); + +class MemFS extends FS +{ + constructor(options={}) + { + super(options); + + let storage = new Map(); + + let superNode = new SuperNode({ fs: this }); + storage.set(superNode.id, superNode); + + let rootNode = new Node({ fs: this, data: { mode: MODE_DIRECTORY } }); + storage.set(rootNode.id, rootNode); + + superNode.rnode = rootNode.id; + + __.set(this, { + storage: storage, + }); + } + + static get type() + { + return "memfs"; + } + + static async mount(dev=UUID.short(), flags=[], options={}) + { + let fs = new MemFS(); + + return fs; + } + + async umount() + { + super.umount(); + } + + async readNode(id) + { + let node = __.get(this).storage.get(id); + + if(!node) { + throw new E.ENOENT(); + } + + return node; + } + + async writeNode(id, node) + { + __.get(this).storage.set(id, node); + } + + async readData(id, block=0) + { + let data = __.get(this).storage.get(`${id}${DATA_BLOCK_SEPARATOR}${block}`); + + if(!data) { + throw new E.EIO(); + } + + return data; + } + + async writeData(id, block, data) + { + __.get(this).storage.set(`${id}${DATA_BLOCK_SEPARATOR}${block}`, data); + } + + async fsync() + { + + } + + async validate(id) + { + + } +} + +export default MemFS; \ No newline at end of file diff --git a/src/fs/providers/root-fs.js b/src/fs/providers/root-fs.js new file mode 100644 index 0000000..ee82aee --- /dev/null +++ b/src/fs/providers/root-fs.js @@ -0,0 +1,96 @@ +import FS from "../fs"; +import SuperNode from "../super-node"; +import Node from "../node"; +import UUID from "../../common/uuid"; +import { MODE_DIRECTORY, MODE_FILE, DATA_BLOCK_SEPARATOR } from "../../common/constants"; +import { SUPER_NODE_ID } from "../../common/constants"; +import E from "../../common/errors"; + +const __ = new WeakMap(); + +/* + RootFS is a read-only file system containing exactly one + directory node. It is created automatically by the VFS + layer. Its only purpose is to allow the VFS to mount another + file system on top of its only node. + */ + +class RootFS extends FS +{ + constructor(options={}) + { + super(options); + + let superNode = new SuperNode({ fs: this, data: { dev: UUID.short() } }); + + let rootNode = new Node({ fs: this, data: { mode: MODE_DIRECTORY, nlinks: 1 } }); + superNode.rnode = rootNode.id; + + let storage = new Map(); + storage.set(superNode.id, superNode.data); + storage.set(rootNode.id, rootNode.data); + + __.set(this, { + storage: storage, + }); + } + + static get type() + { + return "rootfs"; + } + + static async mount() + { + throw new E.UNKNOWN("mount operation not available for rootfs"); + } + + async umount() + { + throw new E.UNKNOWN("umount operation not available for rootfs"); + } + + async readNode(id) + { + let node = __.get(this).storage.get(id); + + if(!node) { + throw new E.ENOENT(); + } + + return node; + } + + async writeNode(id, node) + { + throw new E.EROFS(); + } + + async readData(id, block=0) + { + let data = __.get(this).storage.get(`${id}${DATA_BLOCK_SEPARATOR}${block}`); + + if(!data) { + throw new E.EIO(); + } + + return data; + } + + async writeData(id, block, data) + { + throw new E.EROFS(); + } + + async fsync() + { + + } + + async validate(id) + { + + } +} + +export default RootFS; \ No newline at end of file diff --git a/src/fs/stats.js b/src/fs/stats.js new file mode 100644 index 0000000..a071003 --- /dev/null +++ b/src/fs/stats.js @@ -0,0 +1,97 @@ +const { MODE_FILE, MODE_DIRECTORY, MODE_SYMBOLIC_LINK } = require(`../common/constants`); + +const __ = new WeakMap(); + +class Stats +{ + constructor(fileNode, deviceName) + { + __.set(this, { + node: fileNode.id, + dev: deviceName, + size: fileNode.size, + nlinks: fileNode.nlinks, + atime: fileNode.atime, + mtime: fileNode.mtime, + ctime: fileNode.ctime, + type: fileNode.mode, + }); + } + + get node() + { + return __.get(this).node; + } + + get dev() + { + return __.get(this).dev; + } + + get size() + { + return __.get(this).size; + } + + get nlinks() + { + return __.get(this).nlinks; + } + + get atime() + { + return __.get(this).atime; + } + + get mtime() + { + return __.get(this).mtime; + } + + get ctime() + { + return __.get(this).ctime; + } + + get type() + { + return __.get(this).type; + } + + get isFile() + { + return MODE_FILE == this.type; + } + + get isDirectory() + { + return MODE_DIRECTORY == this.type; + } + + get isSymbolicLink() + { + return MODE_SYMBOLIC_LINK == this.type; + } + + get isSocket() + { + return MODE_SOCKET == this.type; + } + + get isFIFO() + { + return MODE_FIFO == this.type; + } + + get isCharacterDevice() + { + return MODE_CHARACTER_DEVICE == this.type; + } + + get isBlockDevice() + { + return MODE_BLOCK_DEVICE == this.type; + } +} + +export default Stats; \ No newline at end of file diff --git a/src/fs/super-node.js b/src/fs/super-node.js new file mode 100644 index 0000000..4407d36 --- /dev/null +++ b/src/fs/super-node.js @@ -0,0 +1,124 @@ +import { MODE_META } from "../common/constants"; +import { SUPER_NODE_ID } from "../common/constants"; +import UUID from "../common/uuid"; + +const __ = new WeakMap(); + +class SuperNodeData +{ + constructor({ dev, atime = Date.now(), mtime = Date.now(), ctime = Date.now(), rnode, version = UUID.short() } = {}) + { + __.set(this, { + dev: dev, + mode: MODE_META, + atime: atime || Date.now(), // access time (will mirror ctime after creation) + mtime: mtime || Date.now(), // creation/change time + ctime: ctime || Date.now(), // modified time + rnode: rnode, // root node + version: version, + }); + } + + get dev() { return __.get(this).dev } + + get mode() { return __.get(this).mode } + + get atime() { return __.get(this).atime } + set atime(value) { return __.get(this).atime = value } + + get mtime() { return __.get(this).mtime } + set mtime(value) { return __.get(this).mtime = value } + + get ctime() { return __.get(this).ctime } + set ctime(value) { return __.get(this).ctime = value } + + get version() { return __.get(this).version } + set version(value) { return __.get(this).version = value } + + get rnode() { return __.get(this).rnode } + set rnode(value) { return __.get(this).rnode = value } + + toJSON() + { + return { + dev: this.dev, + mode: this.mode, + atime: this.atime, + mtime: this.mtime, + ctime: this.ctime, + rnode: this.rnode, + version: this.version, + }; + } +} + +class SuperNode +{ + constructor({ fs, data } = {}) + { + __.set(this, { + fs: fs, + id: SUPER_NODE_ID, + + data: new SuperNodeData(data), + }); + } + + get id() { return __.get(this).id } + + get fs() { return __.get(this).fs } + + get dev() { return __.get(this).data.dev } + + get mode() { return __.get(this).data.mode } + + get atime() { return __.get(this).data.atime } + set atime(value) { return __.get(this).data.atime = value } + + get mtime() { return __.get(this).data.mtime } + set mtime(value) { return __.get(this).data.mtime = value } + + get ctime() { return __.get(this).data.ctime } + set ctime(value) { return __.get(this).data.ctime = value } + + get rnode() { return __.get(this).data.rnode } + set rnode(value) { return __.get(this).data.rnode = value } + + get version() { return __.get(this).data.version } + set version(value) { return __.get(this).data.version = value } + + get data() { return __.get(this).data.toJSON() } + + static async read(fs) + { + let data = await fs.readNode(SUPER_NODE_ID); + return new SuperNode({ fs: fs, data: data }); + } + + async read() + { + let data = await this.fs.readNode(this.id); + __.get(this).data = new SuperNodeData(data); + } + + async write() + { + this.version = UUID.short(); + await fs.writeNode(this.id, this.data); + } + + toJSON() + { + return { + id: this.id, + data: __.get(this).data.toJSON(), + } + } + + toString() + { + return JSON.stringify(this.toJSON()); + } +} + +export default SuperNode; \ No newline at end of file diff --git a/src/index.js b/src/index.js new file mode 100644 index 0000000..44a36af --- /dev/null +++ b/src/index.js @@ -0,0 +1,15 @@ +import FS from "./fs/index"; +import VFS from "./vfs/index"; +import Providers from "./fs/providers/index"; +import UUID from "./common/uuid"; +import FilerBuffer from "./common/buffer"; +import Crypto from "./common/crypto"; +import URL from "./common/url"; + +export default { + FS: FS, + VFS: VFS, + UUID: UUID, + Buffer: FilerBuffer, + Crypto: Crypto, +}; \ No newline at end of file diff --git a/src/sh/index.js b/src/sh/index.js new file mode 100644 index 0000000..b0eabc4 --- /dev/null +++ b/src/sh/index.js @@ -0,0 +1,12 @@ +const __ = new WeakMap(); + +class Shell +{ + constructor() + { + __.set(this, { + }); + } +} + +export default Shell; \ No newline at end of file diff --git a/src/vfs/directory-entry.js b/src/vfs/directory-entry.js new file mode 100644 index 0000000..9a71372 --- /dev/null +++ b/src/vfs/directory-entry.js @@ -0,0 +1,20 @@ +import { MODE_FILE } from "../common/constants"; + +const __ = new WeakMap(); + +class DirectoryEntry +{ + constructor({ id, type=MODE_FILE } = {}) + { + __.set(this, { + id: id, + type: type, + }); + } + + get id() { return __.get(this).id } + + get type() { return __.get(this).type } +} + +export default DirectoryEntry; \ No newline at end of file diff --git a/src/vfs/fdmap.js b/src/vfs/fdmap.js new file mode 100644 index 0000000..4bb68ec --- /dev/null +++ b/src/vfs/fdmap.js @@ -0,0 +1,49 @@ +import { FIRST_DESCRIPTOR, N_VFS_DESCRIPTORS, STDIN, STDOUT, STDERR } from "../common/constants"; + +const __ = new WeakMap(); + +class FDMap +{ + constructor(size=N_VFS_DESCRIPTORS) + { + const map = new Array(size).fill(0); + + map[STDIN] = 1; + map[STDOUT] = 1; + map[STDERR] = 1; + + __.set(this, { + map: map, + next: FIRST_DESCRIPTOR, + }); + } + + claimUnused() + { + const map = __.get(this).map; + let next = __.get(this).next; + + for(let i = 0; i < map.length; ++ i) + { + let fd = (next+i) % map.length; + if(0 == map[fd]) { + this.claim(fd); + return fd; + } + } + + throw new Error(`unable to allocate file descriptor`); + } + + claim(fd) + { + __.get(this).map[fd] = 1; + } + + release(fd) + { + __.get(this).map[fd] = 0; + } +} + +export default FDMap; \ No newline at end of file diff --git a/src/vfs/index.js b/src/vfs/index.js new file mode 100644 index 0000000..74c6b08 --- /dev/null +++ b/src/vfs/index.js @@ -0,0 +1,3 @@ +import VFS from "./vfs"; + +export default VFS; \ No newline at end of file diff --git a/src/vfs/node-cache.js b/src/vfs/node-cache.js new file mode 100644 index 0000000..2564dd7 --- /dev/null +++ b/src/vfs/node-cache.js @@ -0,0 +1,65 @@ +const __ = new WeakMap(); + +class LRUEntry +{ + constructor(key, value) + { + __.set(this, { + key: key, + value: value, + older: null, + newer: null, + }); + } + + get key() + { + return __.get(this).key; + } + + get value() + { + return __.get(this).value; + } +} + +class LRUMap +{ + constructor(limit) + { + __.set(this, { + size: 0, + limit: limit, + oldest: null, + keyMap: new Map(), + }); + } +} + +class NodeCache +{ + constructor(limit=1024) + { + __.set(this, { + nodes: {}, + lru: [], + }); + } + + insert(node, hash) + { + __.get(this).nodes[hash] = node; + } + + remove(hash) + { + delete __.get(this).nodes[hash]; + } + + find(hash) + { + return __.get(this).nodes[hash] || null; + } +} + +export default NodeCache; \ No newline at end of file diff --git a/src/vfs/vfs-mount-table.js b/src/vfs/vfs-mount-table.js new file mode 100644 index 0000000..52019f2 --- /dev/null +++ b/src/vfs/vfs-mount-table.js @@ -0,0 +1,23 @@ +const __ = new WeakMap(); + +class VFSMountTable() +{ + constructor() + { + __.set(this, { + mounts: {}, + }); + } + + add(vfsmount) + { + + } + + remove() + { + + } +} + +export default VFSMountTable; \ No newline at end of file diff --git a/src/vfs/vfs.js b/src/vfs/vfs.js new file mode 100644 index 0000000..e834d03 --- /dev/null +++ b/src/vfs/vfs.js @@ -0,0 +1,386 @@ +import FDMap from "./fdmap"; +import VFSMount from "./vfsmount"; +import RootFS from "../fs/providers/root-fs"; +import { check as pathCheck, normalize, basename, dirname } from "../common/path"; +import { ROOT_DIRECTORY_NAME } from "../common/constants"; +import Providers from "../fs/providers/index"; +import E from "../common/errors"; +import { SUPER_NODE_ID } from "../common/constants"; +import { MNT_READ_ONLY } from "../common/constants"; +import { SYMLOOP_MAX } from "../common/constants"; +import { MODE_FILE, MODE_DIRECTORY, MODE_SYMBOLIC_LINK } from "../common/constants"; +import UUID from "../common/uuid"; +import DirectoryEntry from "./directory-entry"; +import Node from "../fs/node"; +import SuperNode from "../fs/super-node"; +import URL from "../common/url"; + +const __ = new WeakMap(); + +class InternalVFS +{ + constructor() + { + const rootFS = new RootFS(); + const rootFSVFSMount = new VFSMount({ fs: rootFS, flags: [ MNT_READ_ONLY ] }) + const fsVFSMounts = new WeakMap(); + fsVFSMounts.set(rootFS, rootFSVFSMount); + + __.set(this, { + fdMap: new FDMap(), + + vfsMountsRoot: rootFSVFSMount, + fsVFSMounts: fsVFSMounts, + vfsMounts: new Map(), + }); + } + + async findNode({path, followSymlinks = true} = {}, context) + { + const self = __.get(this); + + if(!context) { + context = { symlinksFollowed: 0 }; + } + + path = normalize(path); + if(!path) { + throw new E.ENOENT("path is an empty string"); + } + + let name = basename(path); + let parentPath = dirname(path); + + let fs; + let nodeId; + if(ROOT_DIRECTORY_NAME == name) { + fs = self.vfsMountsRoot.fs; + let superNode = await SuperNode.read(fs); + nodeId = superNode.rnode; + } else { + let parentDirectoryNode = await this.findNode({ path: parentPath }, context); + fs = parentDirectoryNode.fs; + + if(parentDirectoryNode.mode !== MODE_DIRECTORY) { + throw new E.ENOTDIR("a component of the path prefix is not a directory", path); + } + + let parentDirectoryData; + try { + parentDirectoryData = await parentDirectoryNode.readData(); + } catch(error) { + parentDirectoryData = new Object(); + } + + if(!parentDirectoryData.hasOwnProperty(name)) { + throw new E.ENOENT(null, path); + } + + let directoryEntry = new DirectoryEntry(parentDirectoryData[name]); + nodeId = directoryEntry.id; + } + + // Follow all vfsMounts on this node. + let nodeHash = Node.hash(fs, nodeId); + while(self.vfsMounts.has(nodeHash)) { + let vfsMount = (self.vfsMounts.get(nodeHash))[0]; + fs = vfsMount.fs; + + if(vfsMount.rnode) { + nodeId = vfsMount.rnode; + } else { + let superNode = await SuperNode.read(fs); + nodeId = superNode.rnode; + } + + nodeHash = Node.hash(fs, nodeId); + } + + let node = await Node.read(fs, nodeId); + + if(node.mode == MODE_SYMBOLIC_LINK) { + context.symlinksFollowed += 1; + + if(context.symlinksFollowed > SYMLOOP_MAX) { + throw new E.ELOOP(null, path); + } + + let symlinkPath = await node.readData(); + node = await this.findNode({ path: symlinkPath }, context); + } + + return node; + } + + async mount(fsURL, mountPath, flags, options) + { + const self = __.get(this); + + let mountPoint = await this.findNode({ path: mountPath }); + + if(!mountPoint) { + throw new E.ENOENT("mount target does not exist"); + } + + let url = new URL(fsURL); + + if("filer" !== url.protocol) { + throw new E.UNKNOWN("expecting filer protocol"); + } + + let dev = url.path.slice(1); + let type = url.subprotocol; + + if(!(type in Providers)) { + throw new E.UNKNOWN("unknown file system type"); + } + + let fs = await Providers[type].mount(dev, flags, options); + let superNode = await fs.readNode(SUPER_NODE_ID); + let rootNode = await fs.readNode(superNode.rnode); + + let vfsMount = new VFSMount({ parent: self.fsVFSMounts.get(mountPoint.fs), flags: flags, fs: fs }); + self.fsVFSMounts.set(fs, vfsMount); + + if(!self.vfsMounts.has(mountPoint.hash())) { + self.vfsMounts.set(mountPoint.hash(), new Array()); + } + self.vfsMounts.get(mountPoint.hash()).unshift(vfsMount); + } + + async umount(path) + { + const self = __.get(this); + + let mountNode = await this.findNode({ path: path }); + let fs = mountNode.fs; + + + } + + open(path, flags, mode, callback) + { + + } + + close(fd, callback) + { + + } + + mknod(path, mode, callback) + { + + } + + async mkdir(path, mode) + { + path = normalize(path); + + let name = basename(path); + let parentPath = dirname(path); + + let directoryNode; + try { + directoryNode = await this.findNode({ path: path }); + } catch(error) { + directoryNode = null; + } + + if(directoryNode) { + console.log(directoryNode.toJSON()); + throw new E.EEXIST(null, path); + } + + let parentDirectoryNode = await this.findNode({ path: parentPath }); + let fs = parentDirectoryNode.fs; + + let parentDirectoryData + try { + parentDirectoryData = await parentDirectoryNode.readData(); + } catch(error) { + parentDirectoryData = new Object(); + } + + directoryNode = new Node({ fs: fs, data: { mode: MODE_DIRECTORY, nlinks: 1, data: UUID.short() } }); + directoryNode.write(); + + let directoryData = new Object(); + await directoryNode.writeData(0, directoryData); + + // ! update node a/c/m times + + parentDirectoryData[name] = new DirectoryEntry({ id: directoryNode.id, type: MODE_DIRECTORY }); + await parentDirectoryNode.writeData(0, parentDirectoryData); + + parentDirectoryNode.size = Object.keys(parentDirectoryData).length; + await parentDirectoryNode.write(); + } + + async readdir(path) + { + pathCheck(path); + + let directoryNode = await this.findNode({ path: path }); + let directoryData; + try { + directoryData = await directoryNode.readData(); + } catch(error) { + if(error instanceof E.EIO) + directoryData = new Object(); + } + + let files = Object.keys(directoryData); + return files; + } + + rmdir(path, callback) + { + + } + + stat(path, callback) + { + + } + + fstat(fd, callback) + { + + } + + link(oldpath, newpath, callback) + { + + } + + unlink(path, callback) + { + + } + + read(fd, buffer, offset, length, position, callback) + { + + } + + readFile(path, options, callback) + { + + } + + write(fd, buffer, offset, length, position, callback) + { + + } + + writeFile(path, data, options, callback) + { + + } + + appendFile(path, data, options, callback) + { + + } + + exists(path, callback) + { + + } + + getxattr(path, name, callback) + { + + } + + fgetxattr(fd, name, callback) + { + + } + + setxattr(path, name, value, flag, callback) + { + + } + + fsetxattr(fd, name, value, flag, callback) + { + + } + + removexattr(path, name, callback) + { + + } + + fremovexattr(fd, name, callback) + { + + } + + lseek(fd, offset, whence, callback) + { + + } + + utimes(path, atime, mtime, callback) + { + + } + + futimes(fd, atime, mtime, callback) + { + + } + + rename(oldpath, newpath, callback) + { + + } + + symlink(srcpath, dstpath, type, callback) + { + + } + + readlink(path, callback) + { + + } + + lstat(path, callback) + { + + } + + truncate(path, length, callback) + { + + } + + ftruncate(fd, length, callback) + { + + } +}; + +class VFS +{ + constructor() + { + __.set(this, { + vfs: new InternalVFS(), + }); + } + + async mount(...args) { return await __.get(this).vfs.mount(...args); } + + async umount(...args) { return await __.get(this).vfs.umount(...args); } + + async mkdir(...args) { return await __.get(this).vfs.mkdir(...args); } + + async readdir(...args) { return await __.get(this).vfs.readdir(...args); } +} + +export default VFS; \ No newline at end of file diff --git a/src/vfs/vfsmount.js b/src/vfs/vfsmount.js new file mode 100644 index 0000000..1ebad94 --- /dev/null +++ b/src/vfs/vfsmount.js @@ -0,0 +1,53 @@ +const __ = new WeakMap(); + +class VFSMount +{ + constructor({ parentVFSMount = null, flags = [], fs, rnode = null } = {}) + { + __.set(this, { + flags: flags, + fs: fs, + rnode: rnode, + + parent: parentVFSMount, + children: new Set(), + }); + + if(parentVFSMount) { + parentVFSMount.insertChild(this); + } + } + + get fs() { return __.get(this).fs } + + get rnode() { return __.get(this).rnode } + + get flags() { return __.get(this).flags } + + get parent() { return __.get(this).parent } + + get children() { return __.get(this).children } + + hasChildren() + { + const self = __.get(this); + + return this.children.size > 0; + } + + insertChild(vfsMount) + { + const self = __.get(this); + + self.children.add(vfsMount); + } + + removeChild(vfsMount) + { + const self = __.get(this); + + self.children.delete(vfsMount); + } +}; + +export default VFSMount; \ No newline at end of file diff --git a/test/browser-test.html b/test/browser-test.html new file mode 100644 index 0000000..d45f69c --- /dev/null +++ b/test/browser-test.html @@ -0,0 +1,39 @@ + + + + + + + + + +
+
+ + \ No newline at end of file diff --git a/test/compare.js b/test/compare.js new file mode 100644 index 0000000..56489af --- /dev/null +++ b/test/compare.js @@ -0,0 +1,19 @@ +class X +{ + constructor(a, b) + { + this.a = a; + this.b = b; + } + + valueOf() + { + return `${a}${b}`; + } +} + +let obj1 = new X(1, 2); +let obj2 = new X(1, 2); +let obj3 = new X(2, 3); + +console.log(obj1 === obj2); \ No newline at end of file diff --git a/test/index.js b/test/index.js new file mode 100644 index 0000000..f603f9e --- /dev/null +++ b/test/index.js @@ -0,0 +1,22 @@ +const Filer = require("../dist/filer.js"); +const should = require("should"); + +describe("Filer", () => { + it("should be an object", async () => { + (Filer).should.be.an.Object(); + }); +}); + +describe("Filer.VFS", () => { + it("should be a constructor", async () => { + (Filer.VFS).should.be.a.Function(); + let vfs = new Filer.VFS(); + }); + + it("should create a basic root file system on construction", async () => { + let vfs = new Filer.VFS(); + let rootDirectoryEntries = await vfs.readdir("/"); + + (rootDirectoryEntries).should.deepEqual([]); + }); +}); \ No newline at end of file diff --git a/test/node-test.js b/test/node-test.js new file mode 100644 index 0000000..b2930a2 --- /dev/null +++ b/test/node-test.js @@ -0,0 +1,29 @@ +const log = console.log; +const Filer = require("../dist/filer"); + +let vfs = new Filer.VFS(); + +(async () => { + log(`root directory contents: ${JSON.stringify(await vfs.readdir("/"))}`); + + await vfs.mount(`filer+memfs:///${Filer.UUID.v4()}`, "/"); + log(`root directory contents: ${JSON.stringify(await vfs.readdir("/"))}`); + + await vfs.mkdir("/test1"); + log(`root directory contents: ${JSON.stringify(await vfs.readdir("/"))}`); + + await vfs.mkdir("/test2"); + log(`root directory contents: ${JSON.stringify(await vfs.readdir("/"))}`); + + await vfs.mount(`filer+memfs:///${Filer.UUID.v4()}`, "/"); + log(`root directory contents: ${JSON.stringify(await vfs.readdir("/"))}`); + + await vfs.mkdir("/test3"); + log(`root directory contents: ${JSON.stringify(await vfs.readdir("/"))}`); + + await vfs.mkdir("/test4"); + log(`root directory contents: ${JSON.stringify(await vfs.readdir("/"))}`); + + await vfs.umount("/"); + log(`root directory contents: ${JSON.stringify(await vfs.readdir("/"))}`); +})(); \ No newline at end of file diff --git a/test/uuid-test.js b/test/uuid-test.js new file mode 100644 index 0000000..f25fbe3 --- /dev/null +++ b/test/uuid-test.js @@ -0,0 +1,15 @@ +const crypto = require("crypto"); +const uuidparse = require("uuid-parse"); + +let buffer = new Uint8Array(16); +crypto.randomFillSync(buffer); +console.log(buffer); + +buffer[6] &= 0b00001111; +buffer[6] |= 0b01000000; + +buffer[8] &= 0b00111111; +buffer[8] |= 0b10000000; + +console.log(buffer); +console.log(uuidparse.unparse(buffer)); \ No newline at end of file