core-3nweb-client-lib 0.25.3 → 0.26.0

package/build/lib-common/processes/labelled-exec-pools.js

@@ -0,0 +1,141 @@
+"use strict";
+/*
+ Copyright (C) 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.LabelledExecPools = void 0;
+const assert_1 = require("../assert");
+class ProcessingPool {
+    constructor(label, maxProcs, logError) {
+        this.label = label;
+        this.maxProcs = maxProcs;
+        this.logError = logError;
+        this.inProcess = new Set();
+        this.queue = [];
+        this.isRunning = false;
+        this.doOnError = async (err) => {
+            if (this.logError) {
+                await this.logError(err, `Error in pool ${this.label}`);
+            }
+        };
+        Object.seal(this);
+    }
+    add(task) {
+        this.queue.push(task);
+        if (this.isRunning) {
+            this.processNextQueued();
+        }
+    }
+    async processNextQueued() {
+        if (!this.isRunning || (this.inProcess.size >= this.maxProcs)) {
+            return;
+        }
+        const task = this.queue.shift();
+        if (!task) {
+            return;
+        }
+        if (task.neededExecutor() !== this.label) {
+            return this.processNextQueued();
+        }
+        let proc = undefined;
+        try {
+            proc = task.process().catch(this.doOnError);
+            this.inProcess.add(proc);
+            await proc;
+        }
+        catch (err) {
+            await this.doOnError(err);
+        }
+        finally {
+            if (proc) {
+                this.inProcess.delete(proc);
+            }
+        }
+        return this.processNextQueued();
+    }
+    pause() {
+        this.isRunning = false;
+    }
+    start() {
+        this.isRunning = true;
+        const triggerCount = Math.min(this.maxProcs, this.queue.length);
+        for (let i = 0; i < triggerCount; i += 1) {
+            this.processNextQueued();
+        }
+    }
+    async stop() {
+        if (!this.isRunning) {
+            return;
+        }
+        this.isRunning = false;
+        const cancellations = this.queue.splice(0, this.queue.length)
+            .map(t => t.cancel().catch(this.doOnError));
+        await Promise.all(cancellations.concat(Array.from(this.inProcess)));
+    }
+}
+Object.freeze(ProcessingPool.prototype);
+Object.freeze(ProcessingPool);
+class LabelledExecPools {
+    constructor(setup, logError) {
+        this.pools = new Map();
+        this.isRunning = false;
+        assert_1.assert(setup.length > 0);
+        for (const { label, maxProcs } of setup) {
+            const pool = new ProcessingPool(label, maxProcs, logError);
+            this.pools.set(pool.label, pool);
+        }
+        Object.seal(this);
+    }
+    add(task, queueIfNotRunning = false) {
+        if (!this.isRunning && !queueIfNotRunning) {
+            return;
+        }
+        const label = task.neededExecutor();
+        if (!label) {
+            return;
+        }
+        const pool = this.pools.get(label);
+        if (!pool) {
+            throw new Error(`Task needs unknown pool ${label}`);
+        }
+        pool.add(task);
+    }
+    start() {
+        if (this.isRunning) {
+            return;
+        }
+        this.isRunning = true;
+        for (const pool of this.pools.values()) {
+            pool.start();
+        }
+    }
+    pause() {
+        this.isRunning = false;
+    }
+    async stop() {
+        if (!this.isRunning) {
+            return;
+        }
+        this.isRunning = false;
+        const cancelations = Array.from(this.pools.values())
+            .map(pool => pool.stop());
+        await Promise.all(cancelations);
+    }
+}
+exports.LabelledExecPools = LabelledExecPools;
+Object.freeze(ProcessingPool.prototype);
+Object.freeze(ProcessingPool);
+Object.freeze(exports);

package/build/lib-common/processes/pressure.d.ts

@@ -0,0 +1,7 @@
+export declare class PressureValve {
+    private stopper;
+    constructor();
+    toggle(flag: boolean): void;
+    pressWithError(err: any): void;
+    readonly pressure: () => Promise<void>;
+}

package/build/lib-common/processes/pressure.js

@@ -0,0 +1,56 @@
+"use strict";
+/*
+ Copyright (C) 2015, 2017, 2019 - 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.PressureValve = void 0;
+const error_1 = require("../exceptions/error");
+const deferred_1 = require("./deferred");
+class PressureValve {
+    constructor() {
+        this.stopper = undefined;
+        this.pressure = async () => {
+            if (!this.stopper) {
+                return;
+            }
+            await this.stopper.promise;
+        };
+        Object.seal(this);
+    }
+    toggle(flag) {
+        if (flag) {
+            if (this.stopper) {
+                return;
+            }
+            this.stopper = deferred_1.defer();
+        }
+        else {
+            if (!this.stopper) {
+                return;
+            }
+            this.stopper.resolve();
+            this.stopper = undefined;
+        }
+    }
+    pressWithError(err) {
+        this.toggle(true);
+        this.stopper.reject(error_1.errWithCause(err, `Backpressure error`));
+    }
+}
+exports.PressureValve = PressureValve;
+Object.freeze(PressureValve.prototype);
+Object.freeze(PressureValve);
+Object.freeze(exports);

package/build/lib-common/processes/sleep.d.ts

@@ -0,0 +1 @@
+export declare function sleep(millis: number): Promise<void>;

package/build/lib-common/processes/sleep.js

@@ -0,0 +1,26 @@
+"use strict";
+/*
+ Copyright (C) 2015 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.sleep = void 0;
+function sleep(millis) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, millis).unref();
+    });
+}
+exports.sleep = sleep;
+Object.freeze(exports);

package/build/lib-common/{processes.d.ts → processes/synced.d.ts}

@@ -1,4 +1,3 @@
-export declare function sleep(millis: number): Promise<void>;
 /**
  * This represents a function that will create a promise, potentially starting
  * some background process, only when it is called. Such wrap of code is needed
@@ -68,46 +67,7 @@ export declare class SingleProc {
     private runIfIdle;
     startOrChain<T>(action: Action<T>): Promise<T>;
 }
-export declare class DeduppedRunner<T> {
-    private readonly action;
-    private proc;
-    private waiting;
-    constructor(action: Action<T>);
-    trigger(): Promise<T>;
-    private startAction;
-}
 /**
  * This wraps given function/method into syncing wrap.
  */
 export declare function makeSyncedFunc<T extends Function>(syncProc: SingleProc, thisArg: any, func: T): T;
-export interface Deferred<T> {
-    promise: Promise<T>;
-    resolve: (result?: T | PromiseLike<T>) => void;
-    reject: (err: any) => void;
-}
-export declare function defer<T>(): Deferred<T>;
-export declare class PressureValve {
-    private stopper;
-    constructor();
-    toggle(flag: boolean): void;
-    pressWithError(err: any): void;
-    readonly pressure: () => Promise<void>;
-}
-export declare function callWithTimeout<T>(f: () => Promise<T>, timeout: number, timeoutErr: () => any): Promise<T>;
-export declare class Worker<T> {
-    private readonly process;
-    private readonly stopPendingIn;
-    private readonly queue;
-    private readonly set;
-    private isRunning;
-    private readonly procs;
-    private maxProcs;
-    constructor(process: (w: T) => Promise<void>, stopPendingIn: (queue: T[]) => Promise<void>);
-    add(w: T, queueIfNotRunning?: boolean): void;
-    private addToQueueOnce;
-    private getFromQueueHead;
-    private runQueued;
-    start(maxNumOfProcs: number): void;
-    pause(): void;
-    stop(): Promise<void>;
-}