@entity-access/server-pages 1.0.5 → 1.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@entity-access/server-pages",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "HTTP(s) Web Server for NodeJS",
   "main": "index.js",
   "type": "module",

package/src/ClusterInstance.ts

@@ -0,0 +1,106 @@
+/* eslint-disable no-console */
+import cluster, { Worker } from "cluster";
+import { IProcessLike, Invokable } from "./Invokable.js";
+
+export class RecycledWorker<T = any> {
+
+    public get worker() {
+        return this.currentWorker;
+    }
+
+    private currentWorker: Worker;
+    private destroyed: boolean;
+
+    private eventMap: Map<string,any> = new Map();
+
+    constructor(env?) {
+        this.currentWorker = cluster.fork(env);
+        this.currentWorker.on("exit" , () => {
+            if (this.destroyed) {
+                return;
+            }
+            this.currentWorker = cluster.fork(env);
+            for (const [msg, handler] of this.eventMap) {
+                this.currentWorker.on(msg, handler);
+            }
+        });
+    }
+
+    public on(msg: string, handler) {
+        this.eventMap.set(msg, handler);
+        if (this.destroyed) {
+            return;
+        }
+        this.currentWorker.on(msg, handler);
+    }
+
+    public send(a) {
+        if (this.destroyed) {
+            return;
+        }
+        this.currentWorker.send(a);
+    }
+
+    public destroy() {
+        this.destroyed = true;
+        this.currentWorker = null;
+        this.currentWorker.destroy();
+    }
+
+}
+
+export default abstract class ClusterInstance<T> extends Invokable {
+
+    protected isPrimary: boolean;
+
+    protected readonly workers: RecycledWorker[] = [];
+
+    public run(arg: T) {
+        this.isPrimary = cluster.isPrimary;
+        if (cluster.isPrimary) {
+            console.log(`Initializing Primary Cluster`);
+            this.setupPrimary(arg).catch(console.error);
+        } else {
+            this.setupWorker(arg).catch(console.error);
+            console.log(`Initializing Cluster Worker`);
+        }
+    }
+
+    protected abstract runPrimary(arg: T): Promise<void>;
+    protected abstract runWorker(arg: T): Promise<void>;
+
+    protected fork(env?) {
+        const worker = new RecycledWorker(env);
+        this.install(worker);
+        this.workers.push(worker);
+        return worker;
+    }
+
+    protected async setupPrimary(arg: T) {
+        try {
+            await this.runPrimary(arg);
+        } catch (error) {
+            console.error(error);
+        }
+    }
+
+    protected async setupWorker(arg: T) {
+        try {
+
+            this.install(process);
+
+            await this.runWorker(arg);
+
+            process.send({ cmd: "ready"});
+        } catch (error) {
+            console.error(error);
+        }
+    }
+
+    protected invoke(invoke: string, ...args: any[]): Promise<any> {
+        if (!this.isPrimary) {
+            return Invokable.invoke(this, process, invoke, args);
+        }
+        return Promise.all(this.workers.map((worker) => Invokable.invoke(this, worker, invoke, args)));
+    }
+}

package/src/Invokable.ts

@@ -0,0 +1,71 @@
+
+export interface IProcessLike {
+    on(key: "message", fx: (data: any) => any);
+    send?(data);
+    postMessage?(data);
+}
+
+const defaultResult = null;
+
+let newId = 1;
+
+export class Invokable {
+
+    protected static invoke<T = any>(caller: Invokable, process: IProcessLike, invoke: string, ... args: any[]): Promise<T> {
+        const id = newId++;
+        return new Promise<T>((resolve, reject) => {
+            caller.promiseMap.set(id, { resolve, reject});
+            const send = process.send ?? process.postMessage;
+            send.call(process, { id, invoke, args });
+        });
+    }
+
+    private promiseMap: Map<number, { resolve, reject}> = new Map();
+
+    protected install(process: IProcessLike) {
+        process.on("message", ({
+            id,
+            invoke,
+            args = [],
+            result: resultReceived,
+            error: errorReceived
+        }) => {
+
+            const send = process.send ?? process.postMessage;
+
+            if (!invoke) {
+                if (typeof resultReceived !== "undefined") {
+                    const p = this.promiseMap.get(id);
+                    if (p) {
+                        this.promiseMap.delete(id);
+                        p.resolve(resultReceived);
+                    }
+                    return;
+                }
+                if (errorReceived) {
+                    const p = this.promiseMap.get(id);
+                    if (p) {
+                        this.promiseMap.delete(id);
+                        p.reject(errorReceived);
+                    }
+                }
+                return;
+            }
+            try {
+                const r = this[invoke](... args) ?? defaultResult;
+                if (r.then) {
+                    r.then((result = defaultResult) =>
+                        send.call(process, { id, result })
+                    , (error) =>
+                        send.call(process, { id, error })
+                    );
+                } else {
+                    send.call(process, { id, result: r });
+                }
+            } catch (error) {
+                send.call(process, { id, error });
+            }
+        });
+    }
+
+}