core-3nweb-client-lib 0.44.11 → 0.45.0

package/build/lib-client/cryptor/cryptor-in-worker.js

@@ -1,357 +0,0 @@
-"use strict";
-/*
- Copyright (C) 2020 - 2022 3NSoft Inc.
-
- This program is free software: you can redistribute it and/or modify it under
- the terms of the GNU General Public License as published by the Free Software
- Foundation, either version 3 of the License, or (at your option) any later
- version.
-
- This program is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- See the GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License along with
- this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeInWorkerWasmCryptor = exports.makeInWorkerCryptor = void 0;
-const worker_threads_1 = require("worker_threads");
-const os_1 = require("os");
-const deferred_1 = require("../../lib-common/processes/deferred");
-const error_1 = require("../../lib-common/exceptions/error");
-const path_1 = require("path");
-const assert_1 = require("../../lib-common/assert");
-const serialization_for_wasm_1 = require("./serialization-for-wasm");
-const cryptor_work_labels_1 = require("./cryptor-work-labels");
-const MAX_IDLE_MILLIS = 60 * 1000;
-const jsWorkerFName = 'worker-js.js';
-const wasmWorkerFName = 'worker-wasm.js';
-function workerScriptFor(impl) {
-    // There is a bug with electrons 12, 13, that doesn't let
-    // worker_thread read files from asar pack, even though main thread
-    // makes call from here.
-    // Therefore, in case this runs from asar pack, we should switch to
-    // unpacked in path that is given to worker thread.
-    // Of course, asarUnpack should be used in electron-builder.
-    const asarInd = __dirname.indexOf('app.asar');
-    const dirWithThis = ((asarInd < 0) ?
-        __dirname : `${__dirname.substring(0, asarInd + 8)}.unpacked${__dirname.substring(asarInd + 8)}`);
-    if (impl === 'js') {
-        return (0, path_1.join)(dirWithThis, jsWorkerFName);
-    }
-    else if (impl === 'wasm') {
-        return (0, path_1.join)(dirWithThis, wasmWorkerFName);
-    }
-    else {
-        throw new Error(`Unknown worker implementation ${impl}`);
-    }
-}
-class Workers {
-    constructor(workerScript, logErr, logWarning, maxThreads) {
-        this.workerScript = workerScript;
-        this.logErr = logErr;
-        this.logWarning = logWarning;
-        this.idleWorkers = [];
-        this.allWorkers = new Set();
-        this.waitingForIdle = [];
-        this.replySinks = new Map();
-        this.isClosed = false;
-        this.periodicIdleClean = setInterval(() => {
-            if ((this.isClosed) || (this.idleWorkers.length <= 2)) {
-                return;
-            }
-            const toClose = this.idleWorkers.splice(0, (this.idleWorkers.length - 2));
-            const now = Date.now();
-            for (const { worker, since } of toClose) {
-                if ((now - since) > MAX_IDLE_MILLIS) {
-                    this.detachWorker(worker);
-                }
-            }
-        }, MAX_IDLE_MILLIS).unref();
-        this.maxThreads = Math.max(1, ((typeof maxThreads === 'number') ?
-            maxThreads : (0, os_1.cpus)().length - 1));
-    }
-    numOfIdle() {
-        return this.idleWorkers.length +
-            Math.max(this.maxThreads - this.allWorkers.size, 0);
-    }
-    async getIdleWorker() {
-        const idle = this.idleWorkers.pop();
-        if (idle) {
-            return idle.worker;
-        }
-        if (this.allWorkers.size < this.maxThreads) {
-            return this.makeWorker();
-        }
-        else {
-            const deferred = (0, deferred_1.defer)();
-            this.waitingForIdle.push(deferred);
-            const worker = await deferred.promise;
-            return worker;
-        }
-    }
-    async doRequest(request, trans, d) {
-        if (this.isClosed) {
-            throw new Error(`Async cryptor is already closed`);
-        }
-        const worker = await this.getIdleWorker();
-        this.replySinks.set(worker, d);
-        if (trans) {
-            worker.postMessage(request, trans);
-        }
-        else {
-            worker.postMessage(request);
-        }
-        return d.res.promise;
-    }
-    async makeWorker() {
-        const workerData = {
-            loadDir: (0, path_1.dirname)(this.workerScript)
-        };
-        const worker = new worker_threads_1.Worker(this.workerScript, { workerData });
-        this.allWorkers.add(worker);
-        worker.on('message', (reply) => {
-            const sink = this.replySinks.get(worker);
-            if (!sink) {
-                if (this.allWorkers.has(worker)) {
-                    this.detachWorker(worker);
-                    worker.terminate();
-                    this.logWarning(`Got a message from cryptor worker with no related sink`);
-                    this.makeWorker();
-                }
-                return;
-            }
-            const { res, interim, err } = this.processReply(reply);
-            if (res !== undefined) {
-                this.replySinks.delete(worker);
-                this.declareIdle(worker);
-                sink.res.resolve(res);
-            }
-            else if (err !== undefined) {
-                this.replySinks.delete(worker);
-                this.declareIdle(worker);
-                sink.res.reject(err);
-            }
-            else if (interim !== undefined) {
-                if (sink.interim) {
-                    sink.interim(interim);
-                }
-            }
-            else {
-                this.logWarning(`Reply message from cryptor worker has no fields`);
-                this.detachWorker(worker);
-                worker.terminate();
-                this.makeWorker();
-            }
-        });
-        worker.on('error', err => {
-            const sink = this.replySinks.get(worker);
-            if (sink) {
-                this.replySinks.delete(worker);
-                const errWrapped = (0, error_1.errWithCause)(err, `Error in cryptor worker thread`);
-                this.logErr(errWrapped);
-                sink.res.reject(errWrapped);
-            }
-            this.detachWorker(worker);
-            worker.terminate();
-            this.makeWorker();
-        });
-        worker.on('exit', err => {
-            if (err && !this.isClosed) {
-                this.logErr((0, error_1.errWithCause)(err, `Worker exited with error ${err}`));
-            }
-        });
-        const workerReady = new Promise((resolve, reject) => {
-            const errOnStart = (err) => reject((0, error_1.errWithCause)(err, `Failed to start cryptor worker in thread`));
-            const earlyExit = (exitCode) => reject(new Error(`Thread with worker cryptor exited early with code ${exitCode}`));
-            worker.on('error', errOnStart);
-            worker.on('exit', earlyExit);
-            worker.once('online', () => {
-                resolve();
-                worker.removeListener('error', errOnStart);
-                worker.removeListener('exit', earlyExit);
-            });
-        })
-            .catch(err => {
-            this.detachWorker(worker);
-            throw err;
-        });
-        await workerReady;
-        return worker;
-    }
-    detachWorker(worker) {
-        this.allWorkers.delete(worker);
-        this.replySinks.delete(worker);
-        worker.unref();
-    }
-    declareIdle(worker) {
-        const deferred = this.waitingForIdle.shift();
-        if (deferred) {
-            deferred.resolve(worker);
-        }
-        else {
-            const since = Date.now();
-            this.idleWorkers.push({ worker, since });
-        }
-    }
-    async close() {
-        if (this.isClosed) {
-            return;
-        }
-        this.isClosed = true;
-        clearInterval(this.periodicIdleClean);
-        const exc = new Error(`Async cryptor is closing`);
-        for (const defW of this.waitingForIdle) {
-            defW.reject(exc);
-        }
-        for (const w of this.allWorkers.values()) {
-            await w.terminate();
-            w.unref();
-        }
-        this.allWorkers.clear();
-    }
-}
-Object.freeze(Workers.prototype);
-Object.freeze(Workers);
-class JsWorkers extends Workers {
-    constructor(logErr, logWarning, maxThreads) {
-        super(workerScriptFor('js'), logErr, logWarning, maxThreads);
-    }
-    call(func, args, trans, interim) {
-        return this.doRequest({ func, args }, trans, { res: (0, deferred_1.defer)(), interim });
-    }
-    processReply(reply) {
-        return reply;
-    }
-}
-Object.freeze(JsWorkers.prototype);
-Object.freeze(JsWorkers);
-// XXX can we have no-copy transfer to worker?
-// function transfer(...arrs: Uint8Array[]): ArrayBuffer[]|undefined {
-// 	const transferLst: ArrayBuffer[] = [];
-// 	for (const arr of arrs) {
-// 		const buffer = arr.buffer;
-// 		if (!transferLst.includes(buffer)) {
-// 			transferLst.push(buffer);
-// 		}
-// 	}
-// 	return transferLst;
-// }
-const makeInWorkerCryptor = (logErr, logWarning, maxThreads) => {
-    (0, assert_1.assert)(typeof logErr === 'function');
-    (0, assert_1.assert)(typeof logWarning === 'function');
-    const workers = new JsWorkers(logErr, logWarning, maxThreads);
-    const close = workers.close.bind(workers);
-    const execCounter = new cryptor_work_labels_1.ExecCounter(() => workers.numOfIdle());
-    const cryptor = {
-        scrypt: (passwd, salt, logN, r, p, dkLen, progressCB) => workers.call('scrypt', [passwd, salt, logN, r, p, dkLen], undefined, progressCB),
-        box: {
-            calc_dhshared_key: (pk, sk) => workers.call('box.calc_dhshared_key', [pk, sk]),
-            generate_pubkey: (sk) => workers.call('box.generate_pubkey', [sk])
-        },
-        sbox: {
-            canStartUnderWorkLabel: l => execCounter.canStartUnderWorkLabel(l),
-            open: (c, n, k, workLabel) => execCounter.wrapOpPromise(workLabel, workers.call('sbox.open', [c, n, k])),
-            pack: (m, n, k, workLabel) => execCounter.wrapOpPromise(workLabel, workers.call('sbox.pack', [m, n, k])),
-            formatWN: {
-                open: (cn, k, workLabel) => execCounter.wrapOpPromise(workLabel, workers.call('sbox.formatWN.open', [cn, k])),
-                pack: (m, n, k, workLabel) => execCounter.wrapOpPromise(workLabel, workers.call('sbox.formatWN.pack', [m, n, k]))
-            }
-        },
-        signing: {
-            generate_keypair: (seed) => workers.call('sign.generate_keypair', [seed]),
-            signature: (m, sk) => workers.call('sign.signature', [m, sk]),
-            verify: (sig, m, pk) => workers.call('sign.verify', [sig, m, pk])
-        }
-    };
-    return { cryptor, close };
-};
-exports.makeInWorkerCryptor = makeInWorkerCryptor;
-class WasmWorkers extends Workers {
-    constructor(logErr, logWarning, maxThreads) {
-        super(workerScriptFor('wasm'), logErr, logWarning, maxThreads);
-    }
-    call(req, interim) {
-        const msg = (0, serialization_for_wasm_1.packRequestToWASM)(req);
-        return this.doRequest(msg, undefined, { res: (0, deferred_1.defer)(), interim });
-    }
-    processReply(replyBytes) {
-        const { res, interim, err } = (0, serialization_for_wasm_1.unpackReplyFromWASM)(replyBytes);
-        return {
-            res: res ? res.val : undefined,
-            interim: interim ? interim.val : undefined,
-            err: err ? (0, serialization_for_wasm_1.toLocalErr)(err) : undefined,
-        };
-    }
-}
-Object.freeze(WasmWorkers.prototype);
-Object.freeze(WasmWorkers);
-const makeInWorkerWasmCryptor = (logErr, logWarning, maxThreads) => {
-    (0, assert_1.assert)(typeof logErr === 'function');
-    (0, assert_1.assert)(typeof logWarning === 'function');
-    const workers = new WasmWorkers(logErr, logWarning, maxThreads);
-    const close = workers.close.bind(workers);
-    const execCounter = new cryptor_work_labels_1.ExecCounter(() => workers.numOfIdle());
-    const cryptor = {
-        scrypt: (passwd, salt, logN, r, p, dkLen, progressCB) => workers.call({
-            func: 1,
-            scryptArgs: { passwd, salt, logN, r, p, dkLen }
-        }, (bytes) => progressCB(bytes[0])),
-        box: {
-            calc_dhshared_key: (pk, sk) => workers.call({
-                func: 2,
-                byteArgs: (0, serialization_for_wasm_1.toArgs)(pk, sk)
-            }),
-            generate_pubkey: (sk) => workers.call({
-                func: 3,
-                byteArgs: (0, serialization_for_wasm_1.toArgs)(sk)
-            })
-        },
-        sbox: {
-            canStartUnderWorkLabel: l => execCounter.canStartUnderWorkLabel(l),
-            open: (c, n, k, workLabel) => execCounter.wrapOpPromise(workLabel, workers.call({
-                func: 4,
-                byteArgs: (0, serialization_for_wasm_1.toArgs)(c, n, k)
-            })),
-            pack: (m, n, k, workLabel) => execCounter.wrapOpPromise(workLabel, workers.call({
-                func: 5,
-                byteArgs: (0, serialization_for_wasm_1.toArgs)(m, n, k)
-            })),
-            formatWN: {
-                open: (cn, k, workLabel) => execCounter.wrapOpPromise(workLabel, workers.call({
-                    func: 6,
-                    byteArgs: (0, serialization_for_wasm_1.toArgs)(cn, k)
-                })),
-                pack: (m, n, k, workLabel) => execCounter.wrapOpPromise(workLabel, workers.call({
-                    func: 7,
-                    byteArgs: (0, serialization_for_wasm_1.toArgs)(m, n, k)
-                }))
-            }
-        },
-        signing: {
-            generate_keypair: async (seed) => {
-                const rep = await workers.call({
-                    func: 8,
-                    byteArgs: (0, serialization_for_wasm_1.toArgs)(seed)
-                });
-                return (0, serialization_for_wasm_1.unpackSigningKeyPair)(rep);
-            },
-            signature: (m, sk) => workers.call({
-                func: 9,
-                byteArgs: (0, serialization_for_wasm_1.toArgs)(m, sk)
-            }),
-            verify: async (sig, m, pk) => {
-                const rep = await workers.call({
-                    func: 10,
-                    byteArgs: (0, serialization_for_wasm_1.toArgs)(sig, m, pk)
-                });
-                return (0, serialization_for_wasm_1.unpackBoolVal)(rep);
-            }
-        }
-    };
-    return { cryptor, close };
-};
-exports.makeInWorkerWasmCryptor = makeInWorkerWasmCryptor;
-Object.freeze(exports);