js-dos 0.80.25

package/src/sockdrive/js/src/sockdrive-fat.ts

@@ -0,0 +1,228 @@
+import { createFileSystem } from "./fatfs";
+
+const toBuffer = require("typedarray-to-buffer");
+import { Drive } from "./sockdrive/drive";
+import { Stats as SockdriveStats } from "./sockdrive/types";
+
+export interface Driver {
+    sectorSize: number,
+    numSectors: number,
+    readSectors: (sector: number, dst: Uint8Array, cb: (error: Error | null, dst: Uint8Array) => void) => void,
+    writeSectors: (sector: number, src: Uint8Array, cb: (error: Error | null) => void) => void,
+}
+
+type Callback = (error: Error | null) => void;
+type CallbackT<T> = (error: Error | null, t: T) => void;
+
+export type FileDescriptor = number;
+
+export interface FileSystemApi {
+    mkdir(path: string, cb: Callback): void;
+    readdir(path: string, cb: CallbackT<string[]>): void;
+    open(path: string, flags: string | number, mode: number, cb: CallbackT<FileDescriptor>): void;
+    read(fd: FileDescriptor, buf: Buffer, offset: number,
+        length: number, pos: number | null, cb: CallbackT<number>): void;
+    write(fd: FileDescriptor, buf: Buffer, offset: number,
+        length: number, pos: number | null, cb: CallbackT<number>): void;
+    fstat(fd: FileDescriptor, cb: CallbackT<Stats>): void;
+    close(fd: FileDescriptor, cb: Callback): void;
+}
+
+export type CreateFileSystemApi = (driver: Driver, opts: {
+    ro?: boolean,
+    noatime?: boolean,
+    modmode?: number,
+    umask?: number,
+    uid?: number,
+    gid?: number,
+}, event: (event: "ready" | "error", reason: Error | null) => void) => FileSystemApi;
+export type CreateSockdriveFileSystem = typeof createSockdriveFileSystem;
+
+
+export class FileSystem {
+    fs: FileSystemApi;
+    constructor(fs: FileSystemApi) {
+        this.fs = fs;
+    }
+
+    private promisify<T>(fn: any, ...args: any[]): Promise<T> {
+        return new Promise<T>((resolve, reject) => {
+            fn.call(this.fs, ...args, (err: Error | null, res: T) => {
+                if (!err) {
+                    resolve(res);
+                } else {
+                    reject(err);
+                }
+            });
+        });
+    }
+
+    mkdir(path: string) {
+        return this.promisify<void>(this.fs.mkdir, path);
+    }
+    readdir(path: string) {
+        return this.promisify<string[]>(this.fs.readdir, path);
+    }
+    fopen(path: string, flags: string | number, mode: number) {
+        return this.promisify<FileDescriptor>(this.fs.open, path, flags, mode);
+    }
+    fread(fd: FileDescriptor, buf: Uint8Array, offset: number,
+        length: number, pos: number | null) {
+        return this.promisify<number>(this.fs.read, fd, toBuffer(buf),
+            offset, length, pos);
+    }
+    fwrite(fd: FileDescriptor, buf: Uint8Array, offset: number,
+        length: number, pos: number | null) {
+        return this.promisify<number>(this.fs.write, fd, toBuffer(buf),
+            offset, length, pos);
+    }
+    fstat(fd: FileDescriptor) {
+        return this.promisify<Stats>(this.fs.fstat, fd);
+    }
+    fclose(fd: FileDescriptor) {
+        return this.promisify<void>(this.fs.close, fd);
+    }
+
+    // helpers
+    async stat(path: string) {
+        const fd: number | null = await (this.fopen(path, "\\r", 0o666)
+            .catch((e: Error & { code: string }) => {
+                if (e.code === "NOENT") {
+                    return null;
+                }
+
+                throw e;
+            }));
+        if (fd === null) {
+            return null;
+        }
+        const stat = await this.fstat(fd);
+        await this.fclose(fd);
+        return stat;
+    }
+
+    async isdir(path: string) {
+        const stat = await this.stat(path);
+        return stat !== null ? stat.isDirectory() : false;
+    }
+
+    async exists(path: string) {
+        return (await this.stat(path)) !== null;
+    }
+}
+
+export interface StatsBase<T> {
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isSymbolicLink(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+    dev: T;
+    ino: T;
+    mode: T;
+    nlink: T;
+    uid: T;
+    gid: T;
+    rdev: T;
+    size: T;
+    blksize: T;
+    blocks: T;
+    atimeMs: T;
+    mtimeMs: T;
+    ctimeMs: T;
+    birthtimeMs: T;
+    atime: Date;
+    mtime: Date;
+    ctime: Date;
+    birthtime: Date;
+}
+
+export interface Stats extends StatsBase<number> { }
+
+export async function createSockdriveFileSystem(endpoint: string,
+                                                ownerId: string,
+                                                driveId: string,
+                                                token: string,
+                                                onOpen: (read: boolean, write: boolean) => void = () => {},
+                                                onError: (e: Error) => void = () => {}) {
+    const stats: SockdriveStats = {
+        read: 0,
+        write: 0,
+        readTotalTime: 0,
+        cacheHit: 0,
+        cacheMiss: 0,
+        cacheUsed: 0,
+    };
+
+    const sectorSize = 512;
+    const module = {
+        HEAPU8: new Uint8Array(sectorSize * 255 + sectorSize),
+    };
+
+    // TODO: drive should provide size and disk geometry
+    const drive = new Drive(endpoint, ownerId, driveId, token,
+        stats, module, sectorSize, 255, sectorSize);
+    drive.onOpen(onOpen);
+    drive.onError(onError);
+    const imageSize = 2 * 1024 * 1024 * 1024; // 2GB //FIX!
+
+    // TODO: fatfs should respect boot record section
+    const MBR_OFFSET = 63;
+    const driver: Driver = {
+        sectorSize,
+        numSectors: imageSize / sectorSize,
+        readSectors: function(start, dst, cb) {
+            (async () => {
+                start += MBR_OFFSET;
+                // TODO we can avoid copying in dst.set
+                for (let i = 0; i < dst.length / sectorSize; ++i) {
+                    if (drive.read(start + i, 0, true) !== 0) {
+                        const readCode = await drive.read(start + i, 0, false);
+                        if (readCode !== 0) {
+                            cb(new Error("Read error, code: " + readCode), dst);
+                            return;
+                        }
+                    }
+                    dst.set(module.HEAPU8.slice(0, sectorSize), i * sectorSize);
+                }
+            })()
+                .then(() => cb(null, dst))
+                .catch((e) => cb(e, dst));
+        },
+        writeSectors: function(start, data, cb) {
+            start += MBR_OFFSET;
+            for (let i = 0; i < data.length / sectorSize; ++i) {
+                module.HEAPU8.set(data.slice(i * sectorSize, (i + 1) * sectorSize), 0);
+                const writeCode = drive.write(start + i, 0);
+                if (writeCode !== 0) {
+                    cb(new Error("Write error, code: " + 0));
+                    return;
+                }
+            }
+            cb(null);
+        },
+    };
+
+    const fs = await new Promise<FileSystemApi>((resolve, reject) => {
+        const fs = (createFileSystem as any as CreateFileSystemApi)(driver, {}, (ev, reason) => {
+            if (ev === "ready") {
+                resolve(fs);
+            } else {
+                console.error(ev, reason);
+                reject(reason);
+            }
+        });
+    });
+
+    return {
+        stats,
+        fs: new FileSystem(fs),
+        close: () => drive.close(),
+    };
+}
+
+
+(window as any).createSockdriveFileSystem = createSockdriveFileSystem;
+(window as any).createFileSystem = createFileSystem;

package/src/sockdrive/js/src/sockdrive-native.ts

@@ -0,0 +1,98 @@
+import { Handle, Ptr, Stats } from "./sockdrive/types";
+import { Drive } from "./sockdrive/drive";
+
+interface EmModule {
+    HEAPU8: Uint8Array,
+    _malloc: (len: number) => Ptr,
+    _free: (ptr: Ptr) => void,
+    _decode_lz4_block?: (compressedSize: number,
+        decodedSize: number, ptr: Ptr) => number;
+};
+
+interface Template {
+    name: string,
+    size: number,
+    heads: number,
+    cylinders: number,
+    sectors: number,
+    sector_size: number,
+}
+
+declare const Module: EmModule & any;
+
+(function() {
+    let seq = 0;
+    const mapping: { [handle: Handle]: Drive } = {};
+    const templates: { [handle: number]: Template } = {};
+    const stats: Stats = {
+        read: 0,
+        write: 0,
+        readTotalTime: 0,
+        cacheHit: 0,
+        cacheMiss: 0,
+        cacheUsed: 0,
+    };
+    Module.sockdrive = {
+        stats,
+        onError: (e: Error) => {
+            console.error(e);
+        },
+        onOpen: (drive: string, read: boolean, write: boolean) => {
+            // noop
+        },
+        open: async (url: string, owner: string, name: string, token: string): Promise<Handle> => {
+            const response = await fetch(url.replace("wss://", "https://")
+                .replace("ws://", "http://") + "/template/" + owner + "/" + name);
+            const template = await response.json();
+            if (template.error) {
+                throw new Error(template.error);
+            }
+            seq++;
+            templates[seq] = template;
+            mapping[seq] = new Drive(url, owner, name, token, stats, Module,
+                Module._malloc(512 * 255), 255, 512);
+            mapping[seq].onOpen((read, write) => {
+                Module.sockdrive.onOpen(owner + "/" + name, read, write);
+            });
+            mapping[seq].onError(Module.sockdrive.onError);
+            return seq;
+        },
+        read: (handle: Handle, sector: number, buffer: Ptr, sync: boolean): Promise<number> | number => {
+            if (mapping[handle]) {
+                return mapping[handle].read(sector, buffer, sync);
+            }
+
+            console.error("ERROR! sockdrive handle", handle, "not found");
+            return sync ? 1 : Promise.resolve(1);
+        },
+        write: (handle: Handle, sector: number, buffer: Ptr): number => {
+            if (mapping[handle]) {
+                return mapping[handle].write(sector, buffer);
+            }
+            console.error("ERROR! sockdrive handle", handle, "not found");
+            return 1;
+        },
+        close: (handle: Handle) => {
+            if (mapping[handle]) {
+                Module._free(mapping[handle].readAheadBuffer);
+                mapping[handle].close();
+                delete mapping[handle];
+            }
+        },
+        size: (handle: Handle) => {
+            return templates[handle]?.size ?? 0;
+        },
+        sector_size: (handle: Handle) => {
+            return templates[handle]?.sector_size ?? 512;
+        },
+        heads: (handle: Handle) => {
+            return templates[handle]?.heads ?? 1;
+        },
+        cylinders: (handle: Handle) => {
+            return templates[handle]?.cylinders ?? 520;
+        },
+        sectors: (handle: Handle) => {
+            return templates[handle]?.sectors ?? 63;
+        },
+    };
+})();

package/src/sockdrive/js/src/test/test.ts

@@ -0,0 +1,186 @@
+import { FileSystem, FileSystemApi, CreateFileSystemApi, Driver, CreateSockdriveFileSystem } from "../sockdrive-fat";
+
+declare const createFileSystem: CreateFileSystemApi;
+declare const createSockdriveFileSystem: CreateSockdriveFileSystem;
+
+const baseDir = "/test";
+const file = baseDir + "/Simple File.txt";
+
+async function runTests() {
+    const assert = chai.assert;
+    function createDriver(orig: Uint8Array): Driver {
+        const image = orig.slice(0, orig.length);
+        const sectorSize = 512;
+        return {
+            sectorSize,
+            numSectors: image.length / 512,
+            readSectors: function(sector, dst, cb) {
+                dst.set(image.slice(sector * sectorSize, sector * sectorSize + dst.length));
+                cb(null, dst);
+            },
+            writeSectors: function(sector, data, cb) {
+                image.set(data, sector * sectorSize);
+                cb(null);
+            },
+        };
+    }
+
+    const loadImage = async (url: string) => new Uint8Array(await (await fetch(url)).arrayBuffer());
+    const images: { [key: string]: Uint8Array } = {
+        fat12: await loadImage("test/fat12.img"),
+        fat16: await loadImage("test/fat16.img"),
+        fat32: await loadImage("test/fat32.img"),
+    };
+
+    const writeBuf = new Uint8Array(4096 * 4);
+    for (let i = 0; i < writeBuf.length; ++i) {
+        writeBuf[i] = i % 256;
+    }
+
+    const testRead = async (fs: FileSystem) => {
+        const readBuf = new Uint8Array(writeBuf.length);
+        const fd = await fs.fopen(file, "r", 0o666);
+        assert.equal((await fs.fstat(fd)).size, writeBuf.length);
+        assert.equal(await fs.fread(fd, readBuf, 0, readBuf.length, 0), readBuf.length);
+        assert.deepEqual(readBuf, writeBuf);
+        await fs.fclose(fd);
+    };
+
+    const testOpenWriteStatClose = async (fs: FileSystem) => {
+        try {
+            await fs.mkdir(baseDir);
+        } catch (e) {
+            // ignore if exists
+        }
+        const fd = await fs.fopen(file, "w", 0o666);
+        assert.ok(fd);
+        assert.equal(await fs.fwrite(fd, writeBuf, 0, writeBuf.length, null), writeBuf.length);
+        await fs.fclose(fd);
+        await testRead(fs);
+    };
+
+    const testHelpers = async (fs: FileSystem) => {
+        assert.isFalse(await fs.exists("/not-exists"), "/not-exists not exits");
+        assert.isTrue(await fs.exists(baseDir), "baseDir exists");
+        assert.isTrue(await fs.exists(file), "file exists");
+        assert.isTrue(await fs.isdir(baseDir), "baseDir is dir");
+        assert.isFalse(await fs.isdir(file), "file is file");
+    };
+
+    for (const name of Object.keys(images)) {
+        const driver = () => createDriver(images[name]);
+        const fs = () => new Promise<FileSystemApi>((resolve, reject) => {
+            const fs = createFileSystem(driver(), {}, (ev, reason) => {
+                if (ev === "ready") {
+                    resolve(fs);
+                } else {
+                    console.error(ev, reason);
+                    reject(reason);
+                }
+            });
+        });
+        suite(name + ".driver");
+
+        test("create driver", () => {
+            assert.exists(driver());
+        });
+
+        test("create fs", async () => {
+            assert.exists(await fs());
+        });
+
+        const testFs = (name: string, fn: (fs: FileSystem) => Promise<void>) => {
+            test(name, async () => fn(new FileSystem(await fs())));
+        };
+
+        testFs("api", async (fs) => {
+            for (const method of [
+                "mkdir", "readdir",
+                // "rename", "unlink", "rmdir",
+                "fclose", "fopen", "fwrite", "fread", "fstat",
+                "stat", "exists", "isdir",
+                // "fsync",
+                // "ftruncate", "truncate",
+                // "readFile", "writeFile", "appendFile",
+
+                // "chown", "lchown", "fchown",
+                // "chmod", "lchmod", "fchmod",
+                // "utimes", "futimes",
+                // "lstat", "fstat",
+                // "link", "symlink", "readlink", "realpath",
+
+                // 'watchfile','unwatchfile','watch'
+            ]) {
+                assert.ok(method in fs, "fs." + method + " has implementation.");
+            };
+        });
+
+        testFs("readdir", async (fs) => {
+            const files = await fs.readdir("/");
+            assert.ok(Array.isArray(files));
+            assert.ok(files.length === 0, "image is empty");
+        });
+
+        testFs("mkdir", async (fs) => {
+            await fs.mkdir(baseDir);
+            assert.ok((await fs.readdir(baseDir)).length === 0, "base dir is empty");
+            const root = await fs.readdir("/");
+            assert.ok(root.length === 1, "root have 1 folder");
+            assert.equal("/" + root[0], baseDir);
+        });
+
+        testFs("open/write/stat/read/close", testOpenWriteStatClose);
+
+        testFs("exists/isdir", async (fs) => {
+            await testOpenWriteStatClose(fs);
+            await testHelpers(fs);
+        });
+    }
+
+    suite("sockdrive 127.0.0.1:8001");
+
+    test("error on wrong drive name", (done) => {
+        createSockdriveFileSystem("ws://127.0.0.1:8001", "system", "not-exists", "",
+            () => { },
+            (e) => {
+                assert.strictEqual(e.message, "Err: no such drive");
+                done();
+            });
+    });
+
+    const testSd = (name: string, fn: (fs: FileSystem) => Promise<void>, writeCheck?: number[]) => {
+        test(name, async () => {
+            const { stats, fs, close } = await createSockdriveFileSystem("ws://127.0.0.1:8001", "system", "test", "",
+                (read, write) => {
+                    assert.isTrue(read, "read access");
+                    assert.isTrue(write, "write access");
+                });
+            await fn(fs);
+            await new Promise<void>((resolve) => {
+                setTimeout(resolve, 16);
+            });
+            await close();
+            if (writeCheck) {
+                assert.isTrue(writeCheck.findIndex((v) => v === stats.write) >= 0,
+                    "write check " + stats.write + " in " + writeCheck);
+            }
+        });
+    };
+
+    testSd("connect", async (fs) => {
+        assert.ok(fs);
+    });
+
+    testSd("readdir /", async (fs) => {
+        assert.ok(await fs.readdir("/"));
+    });
+
+    testSd("open/write/stat/read/close", testOpenWriteStatClose);
+    testSd("reconnect stat/read/close", testRead);
+    testSd("exists/isdir", testHelpers);
+
+
+    mocha.run();
+}
+
+(window as any).runTests = runTests;

package/src/sockdrive/js/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "outDir": "./dist/",
+    "noImplicitAny": true,
+    "module": "es6",
+    "target": "es6",
+    "jsx": "react",
+    "allowJs": true,
+    "moduleResolution": "node"
+  }
+}

package/src/sockdrive/js/webpack.config.js

@@ -0,0 +1,68 @@
+const path = require("path");
+const { Compilation, sources, ProvidePlugin } = require("webpack");
+const ESLintPlugin = require("eslint-webpack-plugin");
+
+module.exports = {
+    devtool: "source-map",
+    mode: "production",
+    entry: {
+        sockdriveFat: "./src/sockdrive-fat.ts",
+        sockdriveNative: "./src/sockdrive-native.ts",
+        test: "./src/test/test.ts",
+    },
+    module: {
+        rules: [
+            {
+                test: /\.tsx?$/,
+                use: "ts-loader",
+                exclude: /node_modules/,
+            },
+        ],
+    },
+    resolve: {
+        extensions: [".tsx", ".ts", ".js"],
+        fallback: {
+            stream: require.resolve("stream-browserify"),
+            buffer: require.resolve("buffer"),
+        },
+    },
+    output: {
+        filename: "[name].js",
+        path: path.resolve(__dirname, "dist"),
+    },
+    plugins: [
+        {
+            apply(compiler) {
+                compiler.hooks.thisCompilation.tap("Replace", (compilation) => {
+                    compilation.hooks.processAssets.tap(
+                        {
+                            name: "R_PLUGIN",
+                            stage: Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_HASH,
+                        },
+                        () => {
+                            compilation.updateAsset("sockdriveNative.js",
+                                new sources.RawSource(
+                                    "R\"'''(" +
+                                    compilation.getAsset("sockdriveNative.js").source.source() +
+                                    ")'''\""),
+                            );
+                        },
+                    );
+                });
+            },
+        },
+        new ProvidePlugin({
+            process: "process/browser",
+            Buffer: ["buffer", "Buffer"],
+        }),
+        new ESLintPlugin({
+            fix: true,
+            extensions: ["ts"],
+            useEslintrc: false,
+            overrideConfigFile: ".eslintrc.json",
+        }),
+    ],
+    optimization: {
+        minimize: true,
+    },
+};