@zenfs/core 0.6.0 → 0.7.0

package/dist/backends/AsyncMirror.js

@@ -1,253 +0,0 @@
-import { FileSystem, Sync } from '../filesystem.js';
-import { ApiError, ErrorCode } from '../ApiError.js';
-import { PreloadFile, parseFlag } from '../file.js';
-import { join } from '../emulation/path.js';
-import { rootCred } from '../cred.js';
-/**
- * We define our own file to interpose on syncSync() for mirroring purposes.
- * @internal
- */
-export class MirrorFile extends PreloadFile {
-    constructor(fs, path, flag, stat, data) {
-        super(fs, path, flag, stat, data);
-    }
-    async sync() {
-        this.syncSync();
-    }
-    syncSync() {
-        if (this.isDirty()) {
-            this.fs.syncSync(this.path, this._buffer, this.stats);
-            this.resetDirty();
-        }
-    }
-    async close() {
-        this.closeSync();
-    }
-    closeSync() {
-        this.syncSync();
-    }
-}
-/**
- * AsyncMirrorFS mirrors a synchronous filesystem into an asynchronous filesystem
- * by:
- *
- * * Performing operations over the in-memory copy, while asynchronously pipelining them
- *   to the backing store.
- * * During application loading, the contents of the async file system can be reloaded into
- *   the synchronous store, if desired.
- *
- * The two stores will be kept in sync. The most common use-case is to pair a synchronous
- * in-memory filesystem with an asynchronous backing store.
- *
- */
-export class AsyncMirrorFS extends Sync(FileSystem) {
-    async ready() {
-        await this._ready;
-        return this;
-    }
-    /**
-     *
-     * Mirrors the synchronous file system into the asynchronous file system.
-     *
-     * @param sync The synchronous file system to mirror the asynchronous file system to.
-     * @param async The asynchronous file system to mirror.
-     */
-    constructor({ sync, async }) {
-        super();
-        /**
-         * Queue of pending asynchronous operations.
-         */
-        this._queue = [];
-        this._queueRunning = false;
-        this._isInitialized = false;
-        this._sync = sync;
-        this._async = async;
-        this._ready = this._initialize();
-    }
-    metadata() {
-        return {
-            ...super.metadata(),
-            name: AsyncMirrorFS.name,
-            synchronous: true,
-            supportsProperties: this._sync.metadata().supportsProperties && this._async.metadata().supportsProperties,
-        };
-    }
-    syncSync(path, data, stats) {
-        this._sync.syncSync(path, data, stats);
-        this.enqueue({
-            apiMethod: 'sync',
-            arguments: [path, data, stats],
-        });
-    }
-    openFileSync(path, flag, cred) {
-        return this._sync.openFileSync(path, flag, cred);
-    }
-    createFileSync(path, flag, mode, cred) {
-        const file = this._sync.createFileSync(path, flag, mode, cred);
-        this.enqueue({
-            apiMethod: 'createFile',
-            arguments: [path, flag, mode, cred],
-        });
-        const stats = file.statSync();
-        const buffer = new Uint8Array(stats.size);
-        file.readSync(buffer);
-        return new MirrorFile(this, path, flag, stats, buffer);
-    }
-    linkSync(srcpath, dstpath, cred) {
-        this._sync.linkSync(srcpath, dstpath, cred);
-        this.enqueue({
-            apiMethod: 'link',
-            arguments: [srcpath, dstpath, cred],
-        });
-    }
-    renameSync(oldPath, newPath, cred) {
-        this._sync.renameSync(oldPath, newPath, cred);
-        this.enqueue({
-            apiMethod: 'rename',
-            arguments: [oldPath, newPath, cred],
-        });
-    }
-    statSync(p, cred) {
-        return this._sync.statSync(p, cred);
-    }
-    unlinkSync(p, cred) {
-        this._sync.unlinkSync(p, cred);
-        this.enqueue({
-            apiMethod: 'unlink',
-            arguments: [p, cred],
-        });
-    }
-    rmdirSync(p, cred) {
-        this._sync.rmdirSync(p, cred);
-        this.enqueue({
-            apiMethod: 'rmdir',
-            arguments: [p, cred],
-        });
-    }
-    mkdirSync(p, mode, cred) {
-        this._sync.mkdirSync(p, mode, cred);
-        this.enqueue({
-            apiMethod: 'mkdir',
-            arguments: [p, mode, cred],
-        });
-    }
-    readdirSync(p, cred) {
-        return this._sync.readdirSync(p, cred);
-    }
-    existsSync(p, cred) {
-        return this._sync.existsSync(p, cred);
-    }
-    /**
-     * @internal
-     */
-    async crossCopyDirectory(p, mode) {
-        if (p !== '/') {
-            const stats = await this._async.stat(p, rootCred);
-            this._sync.mkdirSync(p, mode, stats.cred());
-        }
-        const files = await this._async.readdir(p, rootCred);
-        for (const file of files) {
-            await this.crossCopy(join(p, file));
-        }
-    }
-    /**
-     * @internal
-     */
-    async crossCopyFile(p, mode) {
-        const asyncFile = await this._async.openFile(p, parseFlag('r'), rootCred);
-        const syncFile = this._sync.createFileSync(p, parseFlag('w'), mode, rootCred);
-        try {
-            const { size } = await asyncFile.stat();
-            const buffer = new Uint8Array(size);
-            await asyncFile.read(buffer);
-            syncFile.writeSync(buffer);
-        }
-        finally {
-            await asyncFile.close();
-            syncFile.closeSync();
-        }
-    }
-    /**
-     * @internal
-     */
-    async crossCopy(p) {
-        const stats = await this._async.stat(p, rootCred);
-        if (stats.isDirectory()) {
-            await this.crossCopyDirectory(p, stats.mode);
-        }
-        else {
-            await this.crossCopyFile(p, stats.mode);
-        }
-    }
-    /**
-     * Called once to load up files from async storage into sync storage.
-     */
-    async _initialize() {
-        if (this._isInitialized) {
-            return;
-        }
-        try {
-            await this.crossCopy('/');
-            this._isInitialized = true;
-        }
-        catch (e) {
-            this._isInitialized = false;
-            throw e;
-        }
-    }
-    /**
-     * @internal
-     */
-    async _next() {
-        if (this._queue.length == 0) {
-            this._queueRunning = false;
-            return;
-        }
-        const op = this._queue.shift();
-        try {
-            // @ts-expect-error 2556 (since ...args is not correctly picked up as being a tuple)
-            await this._async[op.apiMethod](...op.arguments);
-        }
-        catch (e) {
-            throw new ApiError(ErrorCode.EIO, 'AsyncMirror desync: ' + e);
-        }
-        await this._next();
-    }
-    /**
-     * @internal
-     */
-    enqueue(op) {
-        this._queue.push(op);
-        if (this._queueRunning) {
-            return;
-        }
-        this._queueRunning = true;
-        this._next();
-    }
-}
-export const AsyncMirror = {
-    name: 'AsyncMirror',
-    options: {
-        sync: {
-            type: 'object',
-            required: true,
-            description: 'The synchronous file system to mirror the asynchronous file system to.',
-            validator: async (backend) => {
-                if ('metadata' in backend && !backend.metadata().synchronous) {
-                    throw new ApiError(ErrorCode.EINVAL, '"sync" option must be a file system that supports synchronous operations');
-                }
-            },
-        },
-        async: {
-            type: 'object',
-            required: true,
-            description: 'The asynchronous file system to mirror.',
-        },
-    },
-    isAvailable() {
-        return true;
-    },
-    create(options) {
-        return new AsyncMirrorFS(options);
-    },
-};