pwi-plata-type 0.4.166 → 0.4.167

package/src/libs/cluster.ts

@@ -1,331 +1,331 @@
-import cluster from "node:cluster";
-import { cpus } from "node:os";
-import { PlataClusterController } from './cluster/cluster-controller'
-
-export class PlataClusterManager {
-    private readonly NodeCluster = cluster
-
-    constructor() {
-        if (this.NodeCluster.isPrimary) {
-            if (!Plata.cluster?.isPrimary) {
-                Plata.cluster = {
-                    isPrimary: true,
-                    clusters: []
-                }
-            } 
-
-            if (this.NodeCluster.eventNames().indexOf('exit') === -1) {
-                this.NodeCluster.on('exit', (
-                    t => t._onWorkerKilled(t)
-                )(this))
-            }
-
-            if (this.NodeCluster.eventNames().indexOf('message') === -1) {
-                this.NodeCluster.on('message', (
-                    (t) => t._onMessage(t)
-                )(this))
-            }
-        } else {
-            Plata.cluster = {
-                isPrimary: false
-            }
-        }
-    }
-
-    public async _startCluster(config: Cluster.WorkerConfig): Promise<MaybePlataError> {
-        if (!Plata.cluster.isPrimary) return {
-            errorID: 'PBLCLWS0002',
-            msg: 'startCluster must be called from primary process',
-            error: {
-                stack: new Error().stack
-            }
-        }
-
-        if (config.workers === undefined) {
-            if (config.env === 'prod') {
-                config.workers = cpus().length
-            } else {
-                config.workers = 1
-            }
-        }
-
-        if (config.workers === -1) {
-            config.workers = cpus().length
-        }
-
-        if (config.workers === 0) {
-            return null
-        }
-
-        console.log(`Starting ${config.workers} workers on cluster ${config.name}`)
-
-        const cluster: Cluster.ClusterConfig = {
-            pids: [],
-            config
-        }
-
-        for (let i = 0; i < config.workers; i++) {
-            const w = this._fork(config, false)
-
-            if (w.process.pid === undefined) {
-                return {
-                    errorID: 'PBLCLWS0003',
-                    msg: `Erro while starting worker ${i} from cluster ${config.name}`,
-                    error: w.process.exitCode
-                }
-            }
-
-            cluster.pids.push(w.process.pid)
-        }
-
-        if (config.controller !== undefined) {
-            console.log(`Starting controller worker on cluster ${config.name}`)
-            const w = this._fork(config, true)
-
-            if (w.process.pid === undefined) {
-                return {
-                    errorID: 'PBLCLWS0003',
-                    msg: `Erro while starting controller worker from cluster ${config.name}`,
-                    error: w.process.exitCode
-                }
-            }
-
-            cluster.controllerPid = w.process.pid
-            cluster.pids.push(w.process.pid)
-        }
-
-        if (config.onExit !== undefined) {
-            this.NodeCluster.on(this.getClusterEvents(config.name).worker.exit, config.onExit)
-        }
-
-        Plata.cluster.clusters.push(cluster)
-
-        return null
-    }
-
-    public isPrimary() {
-        return this.NodeCluster.isPrimary
-    }
-
-    public _fork(config: Cluster.WorkerConfig, isController: boolean) {
-        return this.NodeCluster.fork({
-            ...config.workersEnv,
-            ENV: config.env,
-            _PLATA_WORKER_NAME: config.name,
-            _PLATA_WORKER_TYPE: isController ?  'CONTROLLER' : 'WORKER' 
-        })
-    }
-    public getClusterEvents(clusterName: string) {
-        const base = `plata.cluster.${clusterName}`
-        return {
-            worker: {
-                exit: `${base}.worker.exit`
-            }
-        }
-    }
-    public _onWorkerKilled(t: this) {
-        return (worker: Cluster.Worker, code: number, signal: string) => {
-            if (worker.process.pid === undefined) return
-            if (!Plata.cluster.isPrimary) return
-
-            const clusterIndex = Plata.cluster.clusters.findIndex(cluster => 
-                cluster.pids.indexOf(worker.process.pid ?? 0) !== -1
-            )
-
-            if (clusterIndex !== -1) {
-                const c = Plata.cluster.clusters[clusterIndex]
-
-                console.log(`O Worker ${worker.process.pid} do cluster ${c.config.name} morreu com o codigo ${code} ${signal ?? ''}`)
-                console.log(`Iniciando um novo worker no cluster ${c.config.name}`)
-
-                cluster.emit(
-                    t.getClusterEvents(c.config.name).worker.exit,
-                    worker,
-                    code,
-                    signal,
-                )
-
-                const wasController = c.controllerPid === worker.process.pid
-
-                const w = t._fork(c.config, wasController)
-
-                const pidIndex = c.pids.indexOf(worker.process.pid)
-
-                c.pids[pidIndex] = w.process.pid ?? 0
-
-                if (wasController) {
-                    c.controllerPid = w.process.pid ?? 0
-                }
-
-                if (c.controllerPid !== undefined) {
-                    if (wasController) return
-
-                    t._sendMsgToPid(c.controllerPid,  {
-                        action: 'DEAD-WORKER-NOTIFY',
-                        msg: {
-                            clusterName: c.config.name,
-                            newPid: w.process.pid,
-                            pidDead: worker.process.pid,
-                        }
-                    } as any)
-                }
-            }
-        }
-    }
-
-    public async _sendMsgToAllWorkers(msg: Cluster.Actions) {
-        if (this.NodeCluster.workers === undefined) return
-
-        for (const worker of Object.values(this.NodeCluster.workers)) {
-            if (worker === undefined) continue
-            
-            worker.send(msg)
-        }
-    }
-
-    public async sendMsgToCluster(name: string, msg: Cluster.Actions) {
-        if (this.NodeCluster.workers === undefined) return
-        if (!Plata.cluster.isPrimary) return
-
-        const clusterIndex = Plata.cluster.clusters.findIndex(cluster => cluster.config.name === name)
-
-        if (clusterIndex === -1) return
-
-        if (Plata.cluster.clusters[clusterIndex].controllerPid !== undefined) {
-            return this._sendMsgToPid(Plata.cluster.clusters[clusterIndex].controllerPid, msg)
-        }
-
-        const pids = Plata.cluster.clusters[clusterIndex].pids
-
-        for (const worker of Object.values(this.NodeCluster.workers)) {
-            if (worker === undefined) continue
-
-            if (pids.includes(worker.process.pid ?? 0)) 
-                worker.send(msg)
-            ;
-        }
-    }
-
-    public async _sendMsgToPid<T extends Cluster.Actions>(pid: number, msg: T) {
-        if (this.NodeCluster.workers === undefined) return
-        if (!Plata.cluster.isPrimary) return
-
-        for (const worker of Object.values(this.NodeCluster.workers)) {
-            if (worker === undefined) continue
-
-            const wPid = worker.process.pid ?? 0
-
-            if (wPid === pid) 
-                worker.send(msg)
-            ;
-        }
-    }
-
-    public async _getClusterPids(name: string, id: string) {
-        if (this.NodeCluster.workers === undefined) 
-            return this._sendMsgToAllWorkers({
-                action: `GET-PIDS-CLUSTER-RESULT-${id}`,
-                msg: {
-                    errorID: 'PCLGETCLPIDS001',
-                    msg: 'não tem workers online',
-                }
-            })
-        ;
-
-        if (!Plata.cluster.isPrimary) 
-            return this._sendMsgToAllWorkers({
-                action: `GET-PIDS-CLUSTER-RESULT-${id}`,
-                msg: {
-                    errorID: 'PCLGETCLPIDS002',
-                    msg: 'não tem workers online',
-                }
-            })
-        ;
-
-        const clusterIndex = Plata.cluster.clusters.findIndex(cluster => cluster.config.name === name)
-
-        if (clusterIndex === -1) 
-            return this._sendMsgToAllWorkers({
-                action: `GET-PIDS-CLUSTER-RESULT-${id}`,
-                msg: {
-                    errorID: 'PCLGETCLPIDS002',
-                    msg: 'Cluster não encontrado',
-                    error: name
-                }
-            })
-        ;
-
-        return this._sendMsgToAllWorkers({
-            action: `GET-PIDS-CLUSTER-RESULT-${id}`,
-            msg: Plata.cluster.clusters[clusterIndex].pids
-        })
-    }
-
-    public _onMessage(t: this) {
-        return (worker: Cluster.Worker, actionEvent: Cluster.GetActions<Cluster.PlataClusterActions>) =>  {
-            Plata.switchUnionObject(actionEvent, 'action', {
-                _default: async (v) => console.log(`Action inválida: ${actionEvent.action}`),
-
-                "ECHO-CLUSTER": async ({ msg }) => t.sendMsgToCluster(msg.name, msg.data),
-
-                'ECHO-PID': async ({ msg }) => t._sendMsgToPid(msg.pid, msg.data),
-
-                'DEAD-WORKER-NOTIFY': async () => console.log(`Action inválida: ${actionEvent.action}`),
-
-                ECHO: async ({ msg }) => t._sendMsgToAllWorkers(msg),
-
-                KILL: async ({ msg }) => {
-                    console.log(`Process kill requested: ${msg}`)
-                    process.exit(0)
-                },
-
-                RELOAD: async () => t._sendMsgToAllWorkers({ action: 'RELOAD', msg: true }),
-
-                "GET-PIDS-CLUSTER": async ({ msg }) => t._getClusterPids(msg.name.toString(), msg.id),
-            })
-        }   
-    }
-
-    public async send(msg: Cluster.Actions): PlataPromise<boolean> {
-        if (process.send === undefined) {
-            return {
-                errorID: 'PBLCLWS0001',
-                msg: `process don't have send function`,
-                error: {
-                    stack: new Error().stack
-                }
-            }
-        }
-
-        return process.send(msg)
-    }
-
-    public async sendToWorkerPid(pid: number, data: Cluster.UserActions) {
-        return this.send({
-            action: 'ECHO-PID',
-            msg: {
-                pid,
-                data
-            }
-        })
-    }
-
-    public async _onStartCluster(name: string, type: typeof Plata.config._PLATA_WORKER_TYPE) {
-        const c: { default: Cluster.WorkerConfig }  = require(`@@/clusters/${name}`)
-        
-        if (type === 'CONTROLLER' && c.default.controller !== undefined) {
-            const controller = new PlataClusterController(
-                this,
-                name,
-            )
-            
-            await c.default.controller(controller)
-
-            return
-        }
-
-        await c.default.onStart()
-    }
-}
-
+import cluster from "node:cluster";
+import { cpus } from "node:os";
+import { PlataClusterController } from './cluster/cluster-controller'
+
+export class PlataClusterManager {
+    private readonly NodeCluster = cluster
+
+    constructor() {
+        if (this.NodeCluster.isPrimary) {
+            if (!Plata.cluster?.isPrimary) {
+                Plata.cluster = {
+                    isPrimary: true,
+                    clusters: []
+                }
+            } 
+
+            if (this.NodeCluster.eventNames().indexOf('exit') === -1) {
+                this.NodeCluster.on('exit', (
+                    t => t._onWorkerKilled(t)
+                )(this))
+            }
+
+            if (this.NodeCluster.eventNames().indexOf('message') === -1) {
+                this.NodeCluster.on('message', (
+                    (t) => t._onMessage(t)
+                )(this))
+            }
+        } else {
+            Plata.cluster = {
+                isPrimary: false
+            }
+        }
+    }
+
+    public async _startCluster(config: Cluster.WorkerConfig): Promise<MaybePlataError> {
+        if (!Plata.cluster.isPrimary) return {
+            errorID: 'PBLCLWS0002',
+            msg: 'startCluster must be called from primary process',
+            error: {
+                stack: new Error().stack
+            }
+        }
+
+        if (config.workers === undefined) {
+            if (config.env === 'prod') {
+                config.workers = cpus().length
+            } else {
+                config.workers = 1
+            }
+        }
+
+        if (config.workers === -1) {
+            config.workers = cpus().length
+        }
+
+        if (config.workers === 0) {
+            return null
+        }
+
+        console.log(`Starting ${config.workers} workers on cluster ${config.name}`)
+
+        const cluster: Cluster.ClusterConfig = {
+            pids: [],
+            config
+        }
+
+        for (let i = 0; i < config.workers; i++) {
+            const w = this._fork(config, false)
+
+            if (w.process.pid === undefined) {
+                return {
+                    errorID: 'PBLCLWS0003',
+                    msg: `Erro while starting worker ${i} from cluster ${config.name}`,
+                    error: w.process.exitCode
+                }
+            }
+
+            cluster.pids.push(w.process.pid)
+        }
+
+        if (config.controller !== undefined) {
+            console.log(`Starting controller worker on cluster ${config.name}`)
+            const w = this._fork(config, true)
+
+            if (w.process.pid === undefined) {
+                return {
+                    errorID: 'PBLCLWS0003',
+                    msg: `Erro while starting controller worker from cluster ${config.name}`,
+                    error: w.process.exitCode
+                }
+            }
+
+            cluster.controllerPid = w.process.pid
+            cluster.pids.push(w.process.pid)
+        }
+
+        if (config.onExit !== undefined) {
+            this.NodeCluster.on(this.getClusterEvents(config.name).worker.exit, config.onExit)
+        }
+
+        Plata.cluster.clusters.push(cluster)
+
+        return null
+    }
+
+    public isPrimary() {
+        return this.NodeCluster.isPrimary
+    }
+
+    public _fork(config: Cluster.WorkerConfig, isController: boolean) {
+        return this.NodeCluster.fork({
+            ...config.workersEnv,
+            ENV: config.env,
+            _PLATA_WORKER_NAME: config.name,
+            _PLATA_WORKER_TYPE: isController ?  'CONTROLLER' : 'WORKER' 
+        })
+    }
+    public getClusterEvents(clusterName: string) {
+        const base = `plata.cluster.${clusterName}`
+        return {
+            worker: {
+                exit: `${base}.worker.exit`
+            }
+        }
+    }
+    public _onWorkerKilled(t: this) {
+        return (worker: Cluster.Worker, code: number, signal: string) => {
+            if (worker.process.pid === undefined) return
+            if (!Plata.cluster.isPrimary) return
+
+            const clusterIndex = Plata.cluster.clusters.findIndex(cluster => 
+                cluster.pids.indexOf(worker.process.pid ?? 0) !== -1
+            )
+
+            if (clusterIndex !== -1) {
+                const c = Plata.cluster.clusters[clusterIndex]
+
+                console.log(`O Worker ${worker.process.pid} do cluster ${c.config.name} morreu com o codigo ${code} ${signal ?? ''}`)
+                console.log(`Iniciando um novo worker no cluster ${c.config.name}`)
+
+                cluster.emit(
+                    t.getClusterEvents(c.config.name).worker.exit,
+                    worker,
+                    code,
+                    signal,
+                )
+
+                const wasController = c.controllerPid === worker.process.pid
+
+                const w = t._fork(c.config, wasController)
+
+                const pidIndex = c.pids.indexOf(worker.process.pid)
+
+                c.pids[pidIndex] = w.process.pid ?? 0
+
+                if (wasController) {
+                    c.controllerPid = w.process.pid ?? 0
+                }
+
+                if (c.controllerPid !== undefined) {
+                    if (wasController) return
+
+                    t._sendMsgToPid(c.controllerPid,  {
+                        action: 'DEAD-WORKER-NOTIFY',
+                        msg: {
+                            clusterName: c.config.name,
+                            newPid: w.process.pid,
+                            pidDead: worker.process.pid,
+                        }
+                    } as any)
+                }
+            }
+        }
+    }
+
+    public async _sendMsgToAllWorkers(msg: Cluster.Actions) {
+        if (this.NodeCluster.workers === undefined) return
+
+        for (const worker of Object.values(this.NodeCluster.workers)) {
+            if (worker === undefined) continue
+            
+            worker.send(msg)
+        }
+    }
+
+    public async sendMsgToCluster(name: string, msg: Cluster.Actions) {
+        if (this.NodeCluster.workers === undefined) return
+        if (!Plata.cluster.isPrimary) return
+
+        const clusterIndex = Plata.cluster.clusters.findIndex(cluster => cluster.config.name === name)
+
+        if (clusterIndex === -1) return
+
+        if (Plata.cluster.clusters[clusterIndex].controllerPid !== undefined) {
+            return this._sendMsgToPid(Plata.cluster.clusters[clusterIndex].controllerPid, msg)
+        }
+
+        const pids = Plata.cluster.clusters[clusterIndex].pids
+
+        for (const worker of Object.values(this.NodeCluster.workers)) {
+            if (worker === undefined) continue
+
+            if (pids.includes(worker.process.pid ?? 0)) 
+                worker.send(msg)
+            ;
+        }
+    }
+
+    public async _sendMsgToPid<T extends Cluster.Actions>(pid: number, msg: T) {
+        if (this.NodeCluster.workers === undefined) return
+        if (!Plata.cluster.isPrimary) return
+
+        for (const worker of Object.values(this.NodeCluster.workers)) {
+            if (worker === undefined) continue
+
+            const wPid = worker.process.pid ?? 0
+
+            if (wPid === pid) 
+                worker.send(msg)
+            ;
+        }
+    }
+
+    public async _getClusterPids(name: string, id: string) {
+        if (this.NodeCluster.workers === undefined) 
+            return this._sendMsgToAllWorkers({
+                action: `GET-PIDS-CLUSTER-RESULT-${id}`,
+                msg: {
+                    errorID: 'PCLGETCLPIDS001',
+                    msg: 'não tem workers online',
+                }
+            })
+        ;
+
+        if (!Plata.cluster.isPrimary) 
+            return this._sendMsgToAllWorkers({
+                action: `GET-PIDS-CLUSTER-RESULT-${id}`,
+                msg: {
+                    errorID: 'PCLGETCLPIDS002',
+                    msg: 'não tem workers online',
+                }
+            })
+        ;
+
+        const clusterIndex = Plata.cluster.clusters.findIndex(cluster => cluster.config.name === name)
+
+        if (clusterIndex === -1) 
+            return this._sendMsgToAllWorkers({
+                action: `GET-PIDS-CLUSTER-RESULT-${id}`,
+                msg: {
+                    errorID: 'PCLGETCLPIDS002',
+                    msg: 'Cluster não encontrado',
+                    error: name
+                }
+            })
+        ;
+
+        return this._sendMsgToAllWorkers({
+            action: `GET-PIDS-CLUSTER-RESULT-${id}`,
+            msg: Plata.cluster.clusters[clusterIndex].pids
+        })
+    }
+
+    public _onMessage(t: this) {
+        return (worker: Cluster.Worker, actionEvent: Cluster.GetActions<Cluster.PlataClusterActions>) =>  {
+            Plata.switchUnionObject(actionEvent, 'action', {
+                _default: async (v) => console.log(`Action inválida: ${actionEvent.action}`),
+
+                "ECHO-CLUSTER": async ({ msg }) => t.sendMsgToCluster(msg.name, msg.data),
+
+                'ECHO-PID': async ({ msg }) => t._sendMsgToPid(msg.pid, msg.data),
+
+                'DEAD-WORKER-NOTIFY': async () => console.log(`Action inválida: ${actionEvent.action}`),
+
+                ECHO: async ({ msg }) => t._sendMsgToAllWorkers(msg),
+
+                KILL: async ({ msg }) => {
+                    console.log(`Process kill requested: ${msg}`)
+                    process.exit(0)
+                },
+
+                RELOAD: async () => t._sendMsgToAllWorkers({ action: 'RELOAD', msg: true }),
+
+                "GET-PIDS-CLUSTER": async ({ msg }) => t._getClusterPids(msg.name.toString(), msg.id),
+            })
+        }   
+    }
+
+    public async send(msg: Cluster.Actions): PlataPromise<boolean> {
+        if (process.send === undefined) {
+            return {
+                errorID: 'PBLCLWS0001',
+                msg: `process don't have send function`,
+                error: {
+                    stack: new Error().stack
+                }
+            }
+        }
+
+        return process.send(msg)
+    }
+
+    public async sendToWorkerPid(pid: number, data: Cluster.UserActions) {
+        return this.send({
+            action: 'ECHO-PID',
+            msg: {
+                pid,
+                data
+            }
+        })
+    }
+
+    public async _onStartCluster(name: string, type: typeof Plata.config._PLATA_WORKER_TYPE) {
+        const c: { default: Cluster.WorkerConfig }  = require(`@@/clusters/${name}`)
+        
+        if (type === 'CONTROLLER' && c.default.controller !== undefined) {
+            const controller = new PlataClusterController(
+                this,
+                name,
+            )
+            
+            await c.default.controller(controller)
+
+            return
+        }
+
+        await c.default.onStart()
+    }
+}
+
 export * from './cluster/cluster-controller'