@prestack/thread 0.1.3 → 0.1.5

package/dist/integrations/disk.js

@@ -0,0 +1,435 @@
+import * as disk from 'node:fs';
+import { basename, dirname, isAbsolute, relative, resolve } from 'node:path';
+import { env, pid } from 'node:process';
+import { ORDERS } from '../integrations/target.js';
+export const CHANNEL = 'THREAD_CHANNEL';
+export const FOLDER = 'THREAD_FOLDER';
+const WAITING = 180_000;
+const WORKING = 600_000;
+const ASKING = '-asking';
+const ORDER = '-order';
+const ANSWER = '-answer';
+function overFiles(dir) {
+    const idle = new Int32Array(new SharedArrayBuffer(4));
+    let spun = 0;
+    const ask = (body) => {
+        spun += 1;
+        const name = dir + '/' + String(pid) + '-' + String(spun);
+        const long = body.order === 'fetch' ? true : body.order === 'run';
+        const waits = long ? WORKING : WAITING;
+        disk.writeFileSync(name + ASKING, JSON.stringify(body));
+        disk.renameSync(name + ASKING, name + ORDER);
+        const until = Date.now() + waits;
+        for (;;) {
+            let held = '';
+            try {
+                held = disk.readFileSync(name + ANSWER, 'utf8');
+            }
+            catch {
+                held = '';
+            }
+            if (held !== '') {
+                disk.rmSync(name + ANSWER, { force: true });
+                const said = JSON.parse(held);
+                if (said.answered === 'refused')
+                    throw new Error(String(said.because));
+                return said;
+            }
+            if (Date.now() > until) {
+                throw new Error('nothing answered ' + body.order + ' ' + body.at + ' for ' + String(Math.round(waits / 60_000)) +
+                    ' minutes, so this stopped waiting rather than spinning forever. Whoever was answering is gone. ' +
+                    'Nothing here is half-written: one order is one file, and it was either answered or it was not.');
+            }
+            Atomics.wait(idle, 0, 0, 2);
+        }
+    };
+    const took = (body) => {
+        const said = ask(body);
+        const want = ORDERS[body.order];
+        if (said.answered !== want) {
+            throw new Error(body.order + ' ' + body.at + ' was answered as ' + said.answered + ', and that order is answered as ' + want +
+                '. Whatever answered is not the copy of prestack this server sends orders to.');
+        }
+        return said;
+    };
+    const kinds = new Map();
+    const listed = new Map();
+    const reals = new Map();
+    const listing = (at) => {
+        const held = listed.get(at);
+        if (held !== undefined)
+            return held;
+        const found = took({ order: 'list', at }).found;
+        listed.set(at, found);
+        return found;
+    };
+    const kindOf = (at) => {
+        const held = kinds.get(at);
+        if (held !== undefined)
+            return held;
+        const up = dirname(at);
+        if (up !== at && across(up)) {
+            const one = kindOf(up) === 'folder' ? listing(up).find((each) => each.name === basename(at)) : undefined;
+            if (one === undefined) {
+                kinds.set(at, 'none');
+                return 'none';
+            }
+            if (one.kind !== 'other') {
+                kinds.set(at, one.kind);
+                return one.kind;
+            }
+        }
+        const found = took({ order: 'kind', at }).found;
+        kinds.set(at, found);
+        return found;
+    };
+    const wrote = (at) => {
+        kinds.set(at, 'file');
+        for (let child = at, up = dirname(at); up !== child && across(up); child = up, up = dirname(up)) {
+            const inside = listed.get(up);
+            if (inside !== undefined && !inside.some((each) => each.name === basename(child))) {
+                listed.set(up, [...inside, { name: basename(child), kind: child === at ? 'file' : 'folder' }]);
+            }
+            kinds.set(up, 'folder');
+        }
+    };
+    const removed = (at) => {
+        for (const key of [...kinds.keys()])
+            if (key.startsWith(at + '/'))
+                kinds.delete(key);
+        for (const key of [...listed.keys()])
+            if (key === at || key.startsWith(at + '/'))
+                listed.delete(key);
+        reals.clear();
+        kinds.set(at, 'none');
+        const inside = listed.get(dirname(at));
+        if (inside !== undefined)
+            listed.set(dirname(at), inside.filter((each) => each.name !== basename(at)));
+    };
+    const unknown = () => {
+        kinds.clear();
+        listed.clear();
+        reals.clear();
+    };
+    return {
+        kind: kindOf,
+        read: (at) => String(took({ order: 'read', at }).said),
+        write: (at, said, mode) => {
+            took(mode === undefined ? { order: 'write', at, said } : { order: 'write', at, said, mode });
+            wrote(at);
+        },
+        list: listing,
+        stat: (at) => took({ order: 'stat', at }).found,
+        remove: (at) => {
+            took({ order: 'remove', at });
+            removed(at);
+        },
+        real: (at) => {
+            const held = reals.get(at);
+            if (held !== undefined)
+                return held;
+            const found = String(took({ order: 'real', at }).at);
+            reals.set(at, found);
+            return found;
+        },
+        fetch: (at) => {
+            try {
+                return String(took({ order: 'fetch', at }).said);
+            }
+            finally {
+                unknown();
+            }
+        },
+        run: (at, words) => {
+            try {
+                return took({ order: 'run', at, words }).found;
+            }
+            finally {
+                unknown();
+            }
+        },
+    };
+}
+const seam = {};
+const WHERE = env[CHANNEL];
+if (WHERE !== undefined && WHERE !== '')
+    seam.held = overFiles(WHERE);
+export function answeredBy(one) {
+    seam.held = one;
+}
+const placed = (at) => {
+    const root = env[FOLDER] ?? '';
+    return root === '' ? at : resolve(root, at);
+};
+const within = (root, at) => {
+    const step = relative(resolve(root), resolve(root, at));
+    return step === '' || (!step.startsWith('..') && !isAbsolute(step));
+};
+export function across(at) {
+    const root = env[FOLDER] ?? '';
+    return seam.held !== undefined && root !== '' && within(root, at);
+}
+export function beyond(at) {
+    const root = env[FOLDER] ?? '';
+    return seam.held !== undefined && root !== '' && !within(root, at);
+}
+function asked(at) {
+    const one = seam.held;
+    if (one === undefined)
+        return undefined;
+    const root = env[FOLDER] ?? '';
+    if (root === '')
+        return typeof at === 'string' ? one : undefined;
+    if (typeof at !== 'string') {
+        throw new Error('a path given as anything but text cannot be held to ' + root + ', the folder this answers for, so it was not used.');
+    }
+    if (within(root, at))
+        return one;
+    throw new Error(at + ' is outside ' + root + ', the folder this answers for. A command answering for a folder on another machine ' +
+        'reaches that folder and nothing else, so nothing was read, written or removed.');
+}
+export function attached() {
+    return seam.held !== undefined;
+}
+export function here() {
+    return seam.held ?? HERE;
+}
+export function kind(at) {
+    const one = asked(at);
+    return one === undefined ? HERE.kind(at) : one.kind(placed(at));
+}
+export function existsSync(at) {
+    return typeof at === 'string' ? kind(at) !== 'none' : asked(at) === undefined && disk.existsSync(at);
+}
+export function readFileSync(at, how) {
+    const one = asked(at);
+    return one === undefined ? disk.readFileSync(at, how ?? 'utf8') : one.read(placed(at));
+}
+export function writeFileSync(at, said, how) {
+    const held = how === undefined || typeof how === 'string' ? { encoding: how, mode: undefined } : how;
+    const one = asked(at);
+    if (one !== undefined) {
+        one.write(placed(at), said, held.mode);
+        return;
+    }
+    if (typeof at === 'string')
+        disk.mkdirSync(dirname(at), { recursive: true });
+    disk.writeFileSync(at, said, { encoding: held.encoding ?? 'utf8', ...(held.mode === undefined ? {} : { mode: held.mode }) });
+}
+export function createFileSync(at, said) {
+    if (asked(at) !== undefined) {
+        throw new Error(at + ' is on a machine that answers orders, and only a file on this machine can be created for one command alone.');
+    }
+    disk.mkdirSync(dirname(at), { recursive: true });
+    try {
+        disk.writeFileSync(at, said, { encoding: 'utf8', flag: 'wx' });
+        return true;
+    }
+    catch (thrown) {
+        if (thrown.code === 'EEXIST')
+            return false;
+        throw thrown;
+    }
+}
+export function readdirSync(at, how) {
+    const one = asked(at);
+    if (one === undefined)
+        return how === undefined ? disk.readdirSync(at) : disk.readdirSync(at, how);
+    const held = one.list(placed(at));
+    return how === undefined
+        ? held.map((each) => each.name)
+        : held.map((each) => ({ name: each.name, isFile: () => each.kind === 'file', isDirectory: () => each.kind === 'folder' }));
+}
+export function statSync(at, how) {
+    const one = asked(at);
+    if (one === undefined)
+        return (how === undefined ? disk.statSync(at) : disk.statSync(at, how));
+    const path = placed(at);
+    const held = one.kind(path);
+    if (held === 'none') {
+        if (how !== undefined)
+            return undefined;
+        throw new Error(`${path} is not there, so nothing can be said about it.`);
+    }
+    const measured = one.stat(path);
+    return {
+        name: path,
+        size: measured.size,
+        modified: measured.modified,
+        mtimeMs: measured.modified,
+        isFile: () => held === 'file',
+        isDirectory: () => held === 'folder',
+    };
+}
+export function rmSync(at, how) {
+    const one = asked(at);
+    if (one === undefined)
+        disk.rmSync(at, how);
+    else
+        one.remove(placed(at));
+}
+export function rmdirSync(at) {
+    const one = asked(at);
+    if (one === undefined)
+        disk.rmdirSync(at);
+    else
+        one.remove(placed(at));
+}
+export function renameSync(from, to) {
+    const one = asked(from);
+    if (one === undefined) {
+        if (typeof to === 'string')
+            disk.mkdirSync(dirname(to), { recursive: true });
+        disk.renameSync(from, to);
+        return;
+    }
+    asked(to);
+    one.write(placed(to), one.read(placed(from)));
+    one.remove(placed(from));
+}
+export function appendFileSync(at, said) {
+    const one = asked(at);
+    if (one === undefined) {
+        disk.appendFileSync(at, said);
+        return;
+    }
+    const path = placed(at);
+    one.write(path, `${one.kind(path) === 'none' ? '' : one.read(path)}${said}`);
+}
+export function realpathSync(at) {
+    const one = asked(at);
+    return one === undefined ? disk.realpathSync(at) : one.real(placed(at));
+}
+const FILES_ONLY = ' is on this disk, and a disk holds files. ';
+export const HERE = {
+    kind: (at) => {
+        let held;
+        try {
+            held = disk.statSync(at, { throwIfNoEntry: false });
+        }
+        catch (thrown) {
+            if (thrown.code === 'ERR_ACCESS_DENIED')
+                return 'none';
+            throw thrown;
+        }
+        if (held === undefined)
+            return 'none';
+        return held.isFile() ? 'file' : held.isDirectory() ? 'folder' : 'other';
+    },
+    read: (at) => disk.readFileSync(at, 'utf8'),
+    write: (at, said, mode) => {
+        disk.mkdirSync(dirname(at), { recursive: true });
+        disk.writeFileSync(at, said, { encoding: 'utf8', ...(mode === undefined ? {} : { mode }) });
+    },
+    list: (at) => disk.readdirSync(at, { withFileTypes: true }).map((one) => ({
+        name: one.name,
+        kind: one.isFile() ? 'file' : one.isDirectory() ? 'folder' : 'other',
+    })),
+    stat: (at) => {
+        const held = disk.statSync(at);
+        return { size: held.size, modified: held.mtimeMs };
+    },
+    remove: (at) => {
+        if (disk.lstatSync(at, { throwIfNoEntry: false })?.isDirectory() === true)
+            disk.rmdirSync(at);
+        else
+            disk.rmSync(at);
+    },
+    real: (at) => disk.realpathSync(at),
+    fetch: (at) => {
+        throw new Error(at + FILES_ONLY + 'Installing what a tree depends on happens where somebody typed the command, so it cannot be ordered of this disk.');
+    },
+    run: (at) => {
+        throw new Error(at + FILES_ONLY + 'A program is started where somebody typed the command, so running one cannot be ordered of this disk.');
+    },
+};
+const GONE = 'is not in the scenario this trial stands, and while it runs the scenario is the whole tree.';
+const MADE_UP = 'a trial answers orders against a tree it made up, so there is nowhere here to ';
+export function standing(root, given) {
+    const flat = (at) => {
+        let path = at;
+        while (path.length > 1 && path.endsWith('/'))
+            path = path.slice(0, -1);
+        return path;
+    };
+    const under = (at) => at.startsWith(root) || `${at}/` === root;
+    const own = (at) => under(at) && !at.slice(root.length).split('/').includes('node_modules');
+    const beside = (at) => {
+        try {
+            return HERE.list(at);
+        }
+        catch {
+            return [];
+        }
+    };
+    const held = new Map(given);
+    const folders = new Set();
+    const parents = (at) => {
+        for (let up = dirname(at); under(`${up}/`); up = dirname(up))
+            folders.add(up);
+    };
+    for (const at of held.keys())
+        parents(at);
+    const answers = {
+        kind: (at) => (held.has(at) ? 'file' : folders.has(at) ? 'folder' : own(at) ? 'none' : HERE.kind(at)),
+        read: (at) => {
+            const said = held.get(at);
+            if (said !== undefined)
+                return said;
+            if (own(at))
+                throw new Error(`${at} ${GONE}`);
+            return HERE.read(at);
+        },
+        write: (at, said) => {
+            held.set(at, said);
+            parents(at);
+        },
+        list: (at) => {
+            const inside = new Map();
+            const found = own(at) ? [] : folders.has(at) ? beside(at) : HERE.list(at);
+            for (const one of found)
+                inside.set(one.name, { name: one.name, kind: one.kind === 'folder' ? 'folder' : 'file' });
+            for (const path of folders)
+                if (dirname(path) === at)
+                    inside.set(basename(path), { name: basename(path), kind: 'folder' });
+            for (const path of held.keys())
+                if (dirname(path) === at)
+                    inside.set(basename(path), { name: basename(path), kind: 'file' });
+            return [...inside.values()];
+        },
+        stat: (at) => {
+            const said = held.get(at);
+            if (said !== undefined)
+                return { size: said.length, modified: 0 };
+            if (folders.has(at))
+                return { size: 0, modified: 0 };
+            if (own(at))
+                throw new Error(`${at} ${GONE}`);
+            return HERE.stat(at);
+        },
+        remove: (at) => {
+            held.delete(at);
+            folders.delete(at);
+        },
+        real: (at) => (own(at) || held.has(at) || folders.has(at) ? at : HERE.real(at)),
+    };
+    return {
+        kind: (at) => answers.kind(flat(at)),
+        read: (at) => answers.read(flat(at)),
+        write: (at, said) => {
+            answers.write(flat(at), said);
+        },
+        list: (at) => answers.list(flat(at)),
+        stat: (at) => answers.stat(flat(at)),
+        remove: (at) => {
+            answers.remove(flat(at));
+        },
+        real: (at) => answers.real(flat(at)),
+        fetch: () => {
+            throw new Error(MADE_UP + 'install anything into.');
+        },
+        run: () => {
+            throw new Error(MADE_UP + 'run anything in.');
+        },
+    };
+}