exodus-framework 2.0.816 → 2.0.817

package/lib/app/classes/broadcast.d.ts

@@ -0,0 +1,16 @@
+import { Worker } from 'cluster';
+import Managed from './managed';
+import { TClusterBroadCastMessage } from '../../contracts/core';
+declare class Broadcast extends Managed {
+    protected onMasterInit(): void;
+    protected onClusterInit(): void;
+    private masterReceiveMessage;
+    private clusterMessage;
+    broadcastMessage(message: any): void;
+    sendMessageToCluster(clusterId: number, eventKey: string, data: any): void;
+    sendMessageToMaster(eventKey: string, data: any): void;
+    protected onMasterReceiveMessage(_worker: Worker, _message: TClusterBroadCastMessage): void;
+    protected onClusterReceiveMessage(_message: TClusterBroadCastMessage): void;
+}
+export default Broadcast;
+//# sourceMappingURL=broadcast.d.ts.map

package/lib/app/classes/broadcast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"broadcast.d.ts","sourceRoot":"","sources":["../../../src/app/classes/broadcast.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAEjC,OAAO,OAAO,MAAM,WAAW,CAAC;AAChC,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAGhE,cAAM,SAAU,SAAQ,OAAO;IAC7B,SAAS,CAAC,YAAY,IAAI,IAAI;IAY9B,SAAS,CAAC,aAAa,IAAI,IAAI;IAQ/B,OAAO,CAAC,oBAAoB;IAI5B,OAAO,CAAC,cAAc;IAIf,gBAAgB,CAAC,OAAO,EAAE,GAAG;IAU7B,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG;IAanE,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG;IAWtD,SAAS,CAAC,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,wBAAwB;IAGpF,SAAS,CAAC,uBAAuB,CAAC,QAAQ,EAAE,wBAAwB;CAGrE;AAED,eAAe,SAAS,CAAC"}

package/lib/app/classes/broadcast.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _error = require("../error");
+var _managed = _interopRequireDefault(require("./managed"));
+var _event = _interopRequireDefault(require("./event"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class Broadcast extends _managed.default {
+  onMasterInit() {
+    super.onMasterInit();
+    const workers = this.getWorkers();
+    for (const id in workers) {
+      const worker = workers[id];
+      if (worker) {
+        worker.on('message', message => this.masterReceiveMessage(worker, message));
+      }
+    }
+  }
+  onClusterInit() {
+    super.onClusterInit();
+    _event.default.registerProcessMessageHandle(message => this.clusterMessage(message));
+  }
+  masterReceiveMessage(worker, data) {
+    if (!data || !data.data || !data.eventKey) return;
+    this.onMasterReceiveMessage(worker, data);
+  }
+  clusterMessage(message) {
+    this.onClusterReceiveMessage(message);
+  }
+  broadcastMessage(message) {
+    if (this.isCluster()) {
+      return;
+    }
+    const workers = this.getWorkers();
+    for (const id in workers) {
+      workers[id]?.send(message);
+    }
+  }
+  sendMessageToCluster(clusterId, eventKey, data) {
+    if (this.isCluster()) {
+      return;
+    }
+    const worker = this.getWorkers()[clusterId];
+    if (worker) {
+      worker.send({
+        eventKey,
+        data
+      });
+    } else {
+      // TODO
+    }
+  }
+  sendMessageToMaster(eventKey, data) {
+    if (this.isMaster()) {
+      return;
+    }
+    try {
+      process.send({
+        eventKey,
+        data
+      });
+    } catch (error) {
+      new _error.ErrorHandler('Houve um erro ao enviar a mensagem para o master', error);
+    }
+  }
+  onMasterReceiveMessage(_worker, _message) {
+    return;
+  }
+  onClusterReceiveMessage(_message) {
+    return;
+  }
+}
+var _default = exports.default = Broadcast;

package/lib/app/classes/communication.d.ts

@@ -0,0 +1,20 @@
+import EventEmitter from 'events';
+import Broadcast from './broadcast';
+import { TClusterBroadCastMessage } from '../../contracts/core';
+import { Worker } from 'cluster';
+import { eEventCommunication, TMappedEventCommunicationHandlers } from '../../contracts/service';
+declare class RestrictEventCommunication<TransportData = any> extends Broadcast {
+    protected serviceName: string;
+    emitter: EventEmitter;
+    constructor(serviceName: string);
+    sendToServiceCluster(clusterId: number, event: string, data: TransportData): void;
+    sendToServiceMaster(event: string, data: TransportData): void;
+    protected onMasterReceiveMessage(worker: Worker, message: TClusterBroadCastMessage): void;
+    protected onClusterReceiveMessage(message: TClusterBroadCastMessage): void;
+    protected onServiceMasterReceived(worker: Worker, eventKey: string, data: TransportData): void;
+    protected onServiceClusterReceived(eventKey: string, data: TransportData): void;
+    on<T extends eEventCommunication>(key: T, handle: TMappedEventCommunicationHandlers[T]): void;
+    off<T extends eEventCommunication>(key: T, handle: TMappedEventCommunicationHandlers[T]): void;
+}
+export default RestrictEventCommunication;
+//# sourceMappingURL=communication.d.ts.map

package/lib/app/classes/communication.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"communication.d.ts","sourceRoot":"","sources":["../../../src/app/classes/communication.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,QAAQ,CAAC;AAClC,OAAO,SAAS,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACjC,OAAO,EAAE,mBAAmB,EAAE,iCAAiC,EAAE,MAAM,yBAAyB,CAAC;AAEjG,cAAM,0BAA0B,CAAC,aAAa,GAAG,GAAG,CAAE,SAAQ,SAAS;IAGzD,SAAS,CAAC,WAAW,EAAE,MAAM;IAFzC,OAAO,EAAE,YAAY,CAAC;gBAEA,WAAW,EAAE,MAAM;IAKlC,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa;IAI1E,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa;IAM7D,SAAS,CAAC,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,wBAAwB,GAAG,IAAI;IAMzF,SAAS,CAAC,uBAAuB,CAAC,OAAO,EAAE,wBAAwB,GAAG,IAAI;IAQ1E,SAAS,CAAC,uBAAuB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa;IAGvF,SAAS,CAAC,wBAAwB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa;IAIjE,EAAE,CAAC,CAAC,SAAS,mBAAmB,EAAE,GAAG,EAAE,CAAC,EAAE,MAAM,EAAE,iCAAiC,CAAC,CAAC,CAAC;IAGtF,GAAG,CAAC,CAAC,SAAS,mBAAmB,EAAE,GAAG,EAAE,CAAC,EAAE,MAAM,EAAE,iCAAiC,CAAC,CAAC,CAAC;CAG/F;AAED,eAAe,0BAA0B,CAAC"}

package/lib/app/classes/communication.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _events = _interopRequireDefault(require("events"));
+var _broadcast = _interopRequireDefault(require("./broadcast"));
+var _service = require("../../contracts/service");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class RestrictEventCommunication extends _broadcast.default {
+  emitter;
+  constructor(serviceName) {
+    super();
+    this.serviceName = serviceName;
+    this.emitter = new _events.default();
+  }
+  sendToServiceCluster(clusterId, event, data) {
+    const key = `${this.serviceName}_${event}`;
+    this.sendMessageToCluster(clusterId, key, data);
+  }
+  sendToServiceMaster(event, data) {
+    const key = `${this.serviceName}_${event}`;
+    this.sendMessageToMaster(key, data);
+  }
+
+  //#Non Muted
+  onMasterReceiveMessage(worker, message) {
+    if (!message.eventKey.includes(this.serviceName)) return;
+    const key = message.eventKey.replace(this.serviceName + '_', '');
+    this.onServiceMasterReceived(worker, key, message.data);
+  }
+  onClusterReceiveMessage(message) {
+    if (!message.eventKey.includes(this.serviceName)) return;
+    const key = message.eventKey.replace(this.serviceName + '_', '');
+    this.onServiceClusterReceived(key, message.data);
+  }
+
+  //# Muted
+  onServiceMasterReceived(worker, eventKey, data) {
+    this.emitter.emit(_service.eEventCommunication.RECEIVED_CLUSTER_MESSAGE, worker, eventKey, data);
+  }
+  onServiceClusterReceived(eventKey, data) {
+    this.emitter.emit(_service.eEventCommunication.RECEIVED_MASTER_MESSAGE, eventKey, data);
+  }
+  on(key, handle) {
+    this.emitter.on(key, handle);
+  }
+  off(key, handle) {
+    this.emitter.off(key, handle);
+  }
+}
+var _default = exports.default = RestrictEventCommunication;

package/lib/app/classes/event.d.ts

@@ -0,0 +1,30 @@
+import { Worker } from 'cluster';
+import System from './system';
+import { TClusterBroadCastMessage } from '../../contracts/core';
+type cbExit = (code: number, worker: Worker, signal: string) => void;
+type cbProcessExit = (code: number) => void;
+type cbSignal = (signal: NodeJS.Signals) => void;
+type cbException = (err: Error) => void;
+type cbRejection = (reason: unknown, promise: Promise<unknown>) => void;
+type cbMessage = (message: TClusterBroadCastMessage) => void;
+declare class EventManagment extends System {
+    private static workerExitHandles;
+    private static clusterExitHandles;
+    private static processSIGINTHandles;
+    private static processSIGTERMHandles;
+    private static processExceptionHandles;
+    private static processRejectionHandles;
+    private static processExitHandles;
+    private static processMessageHandles;
+    static registerWorkerExitHandle(handle: cbExit): void;
+    static registerClusterExitHandle(handle: cbExit): void;
+    static registerProcessSIGINTHandle(handle: cbSignal): void;
+    static registerProcessSIGTERMHandle(handle: cbSignal): void;
+    static registerProcessExceptionHandle(handle: cbException): void;
+    static registerProcessRejectionHandle(handle: cbRejection): void;
+    static registerProcessExitHandle(handle: cbProcessExit): void;
+    static registerProcessMessageHandle(handle: cbMessage): void;
+    static Start(): void;
+}
+export default EventManagment;
+//# sourceMappingURL=event.d.ts.map

package/lib/app/classes/event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.d.ts","sourceRoot":"","sources":["../../../src/app/classes/event.ts"],"names":[],"mappings":"AAAA,OAAgB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,MAAM,MAAM,UAAU,CAAC;AAC9B,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAEhE,KAAK,MAAM,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;AACrE,KAAK,aAAa,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;AAC5C,KAAK,QAAQ,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,KAAK,IAAI,CAAC;AACjD,KAAK,WAAW,GAAG,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,CAAC;AACxC,KAAK,WAAW,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,IAAI,CAAC;AACxE,KAAK,SAAS,GAAG,CAAC,OAAO,EAAE,wBAAwB,KAAK,IAAI,CAAC;AAE7D,cAAM,cAAe,SAAQ,MAAM;IACjC,OAAO,CAAC,MAAM,CAAC,iBAAiB,CAAgB;IAChD,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAAgB;IACjD,OAAO,CAAC,MAAM,CAAC,oBAAoB,CAAkB;IACrD,OAAO,CAAC,MAAM,CAAC,qBAAqB,CAAkB;IACtD,OAAO,CAAC,MAAM,CAAC,uBAAuB,CAAqB;IAC3D,OAAO,CAAC,MAAM,CAAC,uBAAuB,CAAqB;IAC3D,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAAuB;IACxD,OAAO,CAAC,MAAM,CAAC,qBAAqB,CAAmB;IAEvD,MAAM,CAAC,wBAAwB,CAAC,MAAM,EAAE,MAAM;IAG9C,MAAM,CAAC,yBAAyB,CAAC,MAAM,EAAE,MAAM;IAG/C,MAAM,CAAC,2BAA2B,CAAC,MAAM,EAAE,QAAQ;IAGnD,MAAM,CAAC,4BAA4B,CAAC,MAAM,EAAE,QAAQ;IAGpD,MAAM,CAAC,8BAA8B,CAAC,MAAM,EAAE,WAAW;IAGzD,MAAM,CAAC,8BAA8B,CAAC,MAAM,EAAE,WAAW;IAGzD,MAAM,CAAC,yBAAyB,CAAC,MAAM,EAAE,aAAa;IAGtD,MAAM,CAAC,4BAA4B,CAAC,MAAM,EAAE,SAAS;IAIrD,MAAM,CAAC,KAAK;CAmDb;AAED,eAAe,cAAc,CAAC"}

package/lib/app/classes/event.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _cluster = _interopRequireDefault(require("cluster"));
+var _system = _interopRequireDefault(require("./system"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class EventManagment extends _system.default {
+  static workerExitHandles = [];
+  static clusterExitHandles = [];
+  static processSIGINTHandles = [];
+  static processSIGTERMHandles = [];
+  static processExceptionHandles = [];
+  static processRejectionHandles = [];
+  static processExitHandles = [];
+  static processMessageHandles = [];
+  static registerWorkerExitHandle(handle) {
+    this.workerExitHandles.push(handle);
+  }
+  static registerClusterExitHandle(handle) {
+    this.clusterExitHandles.push(handle);
+  }
+  static registerProcessSIGINTHandle(handle) {
+    this.processSIGINTHandles.push(handle);
+  }
+  static registerProcessSIGTERMHandle(handle) {
+    this.processSIGTERMHandles.push(handle);
+  }
+  static registerProcessExceptionHandle(handle) {
+    this.processExceptionHandles.push(handle);
+  }
+  static registerProcessRejectionHandle(handle) {
+    this.processRejectionHandles.push(handle);
+  }
+  static registerProcessExitHandle(handle) {
+    this.processExitHandles.push(handle);
+  }
+  static registerProcessMessageHandle(handle) {
+    this.processMessageHandles.push(handle);
+  }
+  static Start() {
+    _cluster.default.on('fork', worker => {
+      worker.on('exit', (code, signal) => {
+        for (const cb of this.workerExitHandles) {
+          if (cb) cb(code, worker, signal);
+        }
+      });
+    });
+    _cluster.default.on('exit', (worker, code, signal) => {
+      for (const cb of this.clusterExitHandles) {
+        if (cb) cb(code, worker, signal);
+      }
+    });
+    process.on('SIGINT', signal => {
+      for (const cb of this.processSIGINTHandles) {
+        if (cb) cb(signal);
+      }
+    });
+    process.on('SIGTERM', signal => {
+      for (const cb of this.processSIGTERMHandles) {
+        if (cb) cb(signal);
+      }
+    });
+    process.on('uncaughtException', err => {
+      for (const cb of this.processExceptionHandles) {
+        if (cb) cb(err);
+      }
+    });
+    process.on('unhandledRejection', (reason, promise) => {
+      for (const cb of this.processRejectionHandles) {
+        if (cb) cb(reason, promise);
+      }
+    });
+    process.on('exit', code => {
+      for (const cb of this.processExitHandles) {
+        if (cb) cb(code);
+      }
+    });
+    process.on('message', message => {
+      for (const cb of this.processMessageHandles) {
+        if (cb) cb(message);
+      }
+    });
+  }
+}
+var _default = exports.default = EventManagment;

package/lib/app/classes/managed.d.ts

@@ -0,0 +1,53 @@
+import { Worker } from 'cluster';
+import System from './system';
+declare abstract class Managed extends System {
+    private _isMaster;
+    private _isCluster;
+    constructor();
+    private init;
+    private initProcessHandles;
+    private exit;
+    private SIGINT;
+    private SIGTERM;
+    private uncaughtException;
+    private unhandledRejection;
+    private masterInit;
+    private masterExit;
+    private masterSIGINT;
+    private masterSIGTERM;
+    private masterUncaughtException;
+    private masterUnhandledRejection;
+    private clusterInit;
+    private clusterDown;
+    private clusterExit;
+    private clusterSIGINT;
+    private clusterSIGTERM;
+    private clusterUncaughtException;
+    private clusterUnhandledRejection;
+    protected onInit(): void;
+    protected onClusterInit(): void;
+    protected onMasterInit(): void;
+    protected onExit(_code: number): void;
+    protected onClusterExit(_code: number): void;
+    protected onMasterExit(_code: number): void;
+    protected onClusterDown(_code: number, _worker: Worker, _signal: string): void;
+    protected onSIGINT(_signal: NodeJS.Signals): void;
+    protected onClusterSIGINT(_signal: NodeJS.Signals): void;
+    protected onMasterSIGINT(_signal: NodeJS.Signals): void;
+    protected onSIGTERM(_signal: NodeJS.Signals): void;
+    protected onClusterSIGTERM(_signal: NodeJS.Signals): void;
+    protected onMasterSIGTERM(_signal: NodeJS.Signals): void;
+    protected onUncaughtException(_err: Error): void;
+    protected onClusterUncaughtException(_err: Error): void;
+    protected onMasterUncaughtException(_err: Error): void;
+    protected onUnhandledRejection(_reason: unknown, _promise: Promise<unknown>): void;
+    protected onClusterUnhandledRejection(_reason: unknown, _promise: Promise<unknown>): void;
+    protected onMasterUnhandledRejection(_reason: unknown, _promise: Promise<unknown>): void;
+    protected isMaster(): boolean;
+    protected isCluster(): boolean;
+    protected getWorkers(): NodeJS.Dict<Worker>;
+    protected getWorkId(): number;
+    protected getClusterCount(): number;
+}
+export default Managed;
+//# sourceMappingURL=managed.d.ts.map

package/lib/app/classes/managed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed.d.ts","sourceRoot":"","sources":["../../../src/app/classes/managed.ts"],"names":[],"mappings":"AAAA,OAAgB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,MAAM,MAAM,UAAU,CAAC;AAG9B,uBAAe,OAAQ,SAAQ,MAAM;IACnC,OAAO,CAAC,SAAS,CAAU;IAC3B,OAAO,CAAC,UAAU,CAAU;;IAc5B,OAAO,CAAC,IAAI;IAUZ,OAAO,CAAC,kBAAkB;IAyD1B,OAAO,CAAC,IAAI;IAGZ,OAAO,CAAC,MAAM;IAGd,OAAO,CAAC,OAAO;IAGf,OAAO,CAAC,iBAAiB;IAGzB,OAAO,CAAC,kBAAkB;IAK1B,OAAO,CAAC,UAAU;IAgBlB,OAAO,CAAC,UAAU;IAGlB,OAAO,CAAC,YAAY;IAGpB,OAAO,CAAC,aAAa;IAGrB,OAAO,CAAC,uBAAuB;IAG/B,OAAO,CAAC,wBAAwB;IAKhC,OAAO,CAAC,WAAW;IAGnB,OAAO,CAAC,WAAW;IAGnB,OAAO,CAAC,WAAW;IAGnB,OAAO,CAAC,aAAa;IAGrB,OAAO,CAAC,cAAc;IAGtB,OAAO,CAAC,wBAAwB;IAGhC,OAAO,CAAC,yBAAyB;IAKjC,SAAS,CAAC,MAAM;IAChB,SAAS,CAAC,aAAa;IACvB,SAAS,CAAC,YAAY;IAEtB,SAAS,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM;IAC9B,SAAS,CAAC,aAAa,CAAC,KAAK,EAAE,MAAM;IACrC,SAAS,CAAC,YAAY,CAAC,KAAK,EAAE,MAAM;IACpC,SAAS,CAAC,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IAEvE,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,OAAO;IAC1C,SAAS,CAAC,eAAe,CAAC,OAAO,EAAE,MAAM,CAAC,OAAO;IACjD,SAAS,CAAC,cAAc,CAAC,OAAO,EAAE,MAAM,CAAC,OAAO;IAEhD,SAAS,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC,OAAO;IAC3C,SAAS,CAAC,gBAAgB,CAAC,OAAO,EAAE,MAAM,CAAC,OAAO;IAClD,SAAS,CAAC,eAAe,CAAC,OAAO,EAAE,MAAM,CAAC,OAAO;IAEjD,SAAS,CAAC,mBAAmB,CAAC,IAAI,EAAE,KAAK;IACzC,SAAS,CAAC,0BAA0B,CAAC,IAAI,EAAE,KAAK;IAChD,SAAS,CAAC,yBAAyB,CAAC,IAAI,EAAE,KAAK;IAE/C,SAAS,CAAC,oBAAoB,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC,OAAO,CAAC;IAC3E,SAAS,CAAC,2BAA2B,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC,OAAO,CAAC;IAClF,SAAS,CAAC,0BAA0B,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC,OAAO,CAAC;IAGjF,SAAS,CAAC,QAAQ;IAGlB,SAAS,CAAC,SAAS;IAKnB,SAAS,CAAC,UAAU;IAGpB,SAAS,CAAC,SAAS;IAMnB,SAAS,CAAC,eAAe;CAG1B;AAED,eAAe,OAAO,CAAC"}

package/lib/app/classes/managed.js

@@ -0,0 +1,192 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _cluster = _interopRequireDefault(require("cluster"));
+var _system = _interopRequireDefault(require("./system"));
+var _event = _interopRequireDefault(require("./event"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class Managed extends _system.default {
+  _isMaster;
+  _isCluster;
+  constructor() {
+    super();
+    if (_cluster.default.isPrimary) {
+      this._isMaster = true;
+    } else {
+      this._isCluster = true;
+    }
+    this.init();
+  }
+
+  //# Common
+  init() {
+    this.initProcessHandles();
+    this.onInit();
+    if (this.isCluster()) {
+      this.clusterInit();
+    }
+    if (this.isMaster()) {
+      this.masterInit();
+    }
+  }
+  initProcessHandles() {
+    _event.default.registerProcessSIGINTHandle(signal => {
+      this.SIGINT(signal);
+      if (this.isMaster()) {
+        this.masterSIGINT(signal);
+      }
+      if (this.isCluster()) {
+        this.clusterSIGINT(signal);
+      }
+    });
+    _event.default.registerProcessSIGTERMHandle(signal => {
+      this.SIGTERM(signal);
+      if (this.isMaster()) {
+        this.masterSIGTERM(signal);
+      }
+      if (this.isCluster()) {
+        this.clusterSIGTERM(signal);
+      }
+    });
+    _event.default.registerProcessExceptionHandle(err => {
+      this.uncaughtException(err);
+      if (this.isMaster()) {
+        this.masterUncaughtException(err);
+      }
+      if (this.isCluster()) {
+        this.clusterUncaughtException(err);
+      }
+    });
+    _event.default.registerProcessRejectionHandle((reason, promise) => {
+      this.unhandledRejection(reason, promise);
+      if (this.isMaster()) {
+        this.masterUnhandledRejection(reason, promise);
+      }
+      if (this.isCluster()) {
+        this.clusterUnhandledRejection(reason, promise);
+      }
+    });
+    _event.default.registerProcessExitHandle(code => {
+      this.exit(code);
+      if (this.isMaster()) {
+        this.masterExit(code);
+      }
+      if (this.isCluster()) {
+        this.clusterExit(code);
+      }
+    });
+  }
+  exit(code) {
+    this.onExit(code);
+  }
+  SIGINT(signal) {
+    this.onSIGINT(signal);
+  }
+  SIGTERM(signal) {
+    this.onSIGTERM(signal);
+  }
+  uncaughtException(err) {
+    this.onUncaughtException(err);
+  }
+  unhandledRejection(reason, promise) {
+    this.onUnhandledRejection(reason, promise);
+  }
+
+  //# Master
+  masterInit() {
+    const workers = this.getWorkers();
+    for (const id in workers) {
+      const worker = workers[id];
+      if (worker) {
+        worker.on('exit', (code, signal) => this.clusterDown(code, worker, signal));
+      }
+    }
+    _event.default.registerWorkerExitHandle((code, worker, signal) => this.clusterDown(code, worker, signal));
+    this.onMasterInit();
+  }
+  masterExit(code) {
+    this.onMasterExit(code);
+  }
+  masterSIGINT(signal) {
+    this.onMasterSIGINT(signal);
+  }
+  masterSIGTERM(signal) {
+    this.onMasterSIGTERM(signal);
+  }
+  masterUncaughtException(err) {
+    this.onMasterUncaughtException(err);
+  }
+  masterUnhandledRejection(reason, promise) {
+    this.onMasterUnhandledRejection(reason, promise);
+  }
+
+  //# Cluster
+  clusterInit() {
+    this.onClusterInit();
+  }
+  clusterDown(code, worker, signal) {
+    this.onClusterDown(code, worker, signal);
+  }
+  clusterExit(code) {
+    this.onClusterExit(code);
+  }
+  clusterSIGINT(signal) {
+    this.clusterSIGINT(signal);
+  }
+  clusterSIGTERM(signal) {
+    this.onClusterSIGTERM(signal);
+  }
+  clusterUncaughtException(err) {
+    this.onClusterUncaughtException(err);
+  }
+  clusterUnhandledRejection(reason, promise) {
+    this.onClusterUnhandledRejection(reason, promise);
+  }
+
+  //# Muted
+  onInit() {}
+  onClusterInit() {}
+  onMasterInit() {}
+  onExit(_code) {}
+  onClusterExit(_code) {}
+  onMasterExit(_code) {}
+  onClusterDown(_code, _worker, _signal) {}
+  onSIGINT(_signal) {}
+  onClusterSIGINT(_signal) {}
+  onMasterSIGINT(_signal) {}
+  onSIGTERM(_signal) {}
+  onClusterSIGTERM(_signal) {}
+  onMasterSIGTERM(_signal) {}
+  onUncaughtException(_err) {}
+  onClusterUncaughtException(_err) {}
+  onMasterUncaughtException(_err) {}
+  onUnhandledRejection(_reason, _promise) {}
+  onClusterUnhandledRejection(_reason, _promise) {}
+  onMasterUnhandledRejection(_reason, _promise) {}
+
+  //# Utils
+  isMaster() {
+    return this._isMaster;
+  }
+  isCluster() {
+    return this._isCluster;
+  }
+
+  //# Getters
+  getWorkers() {
+    return _cluster.default.workers;
+  }
+  getWorkId() {
+    if (this.isMaster()) {
+      return -1;
+    }
+    return _cluster.default.worker.id;
+  }
+  getClusterCount() {
+    return Object.values(_cluster.default.workers || {}).filter(worker => worker?.isConnected()).length;
+  }
+}
+var _default = exports.default = Managed;

package/lib/app/classes/service.d.ts

@@ -0,0 +1,23 @@
+import { Worker } from 'cluster';
+import { NonConstructor } from '../../contracts';
+import Managed from './managed';
+type TStaticService<S> = NonConstructor<typeof Service> & {
+    new (): S;
+};
+declare abstract class Service<D = any> extends Managed {
+    static instance: Service;
+    private eCom;
+    static singleton<S extends Service>(this: TStaticService<S>): S;
+    static getService<S extends Service>(this: TStaticService<S>): S;
+    protected onInit(): void;
+    serviceInit(): Promise<void>;
+    protected onServiceInit(): Promise<void>;
+    protected onServiceMasterInit(): Promise<void>;
+    protected onServiceClusterInit(): Promise<void>;
+    protected sendToServiceCluster(clusterId: number, event: string, data: D): void;
+    protected sendToServiceMaster(event: string, data: D): void;
+    protected onServiceMasterReceived(_worker: Worker, _eventKey: string, _data: any): void;
+    protected onServiceClusterReceived(_eventKey: string, _data: any): void;
+}
+export default Service;
+//# sourceMappingURL=service.d.ts.map

package/lib/app/classes/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../src/app/classes/service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACjC,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGjD,OAAO,OAAO,MAAM,WAAW,CAAC;AAEhC,KAAK,cAAc,CAAC,CAAC,IAAI,cAAc,CAAC,OAAO,OAAO,CAAC,GAAG;IACxD,QAAQ,CAAC,CAAC;CACX,CAAC;AAWF,uBAAe,OAAO,CAAC,CAAC,GAAG,GAAG,CAAE,SAAQ,OAAO;IAC7C,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC;IACzB,OAAO,CAAC,IAAI,CAA6B;IAEzC,MAAM,CAAC,SAAS,CAAC,CAAC,SAAS,OAAO,EAAE,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,GAEjC,CAAC;IAE3B,MAAM,CAAC,UAAU,CAAC,CAAC,SAAS,OAAO,EAAE,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC;IAI5D,SAAS,CAAC,MAAM,IAAI,IAAI;IAKX,WAAW;cAsBR,aAAa;cAGb,mBAAmB;cAGnB,oBAAoB;IAIpC,SAAS,CAAC,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;IAGxE,SAAS,CAAC,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;IAIpD,SAAS,CAAC,uBAAuB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG;IAGhF,SAAS,CAAC,wBAAwB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG;CAGjE;AACD,eAAe,OAAO,CAAC"}

package/lib/app/classes/service.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _service = require("../../contracts/service");
+var _communication = _interopRequireDefault(require("./communication"));
+var _managed = _interopRequireDefault(require("./managed"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Classe base de Serviços
+ * Responsável por gerênciar métodos e funções utilizadas por todas
+ * as classes de serviço desta aplicação
+ *
+ * @abstract
+ * @class Service
+ * @extends {Managed}
+ * @template S
+ */
+class Service extends _managed.default {
+  static instance;
+  eCom;
+  static singleton() {
+    if (!this.instance) this.instance = new this();
+    return this.instance;
+  }
+  static getService() {
+    return this.singleton();
+  }
+  onInit() {
+    super.onInit();
+    this.eCom = new _communication.default(this.constructor.name);
+  }
+  async serviceInit() {
+    this.eCom.on(_service.eEventCommunication.RECEIVED_CLUSTER_MESSAGE, this.onServiceMasterReceived.bind(this));
+    this.eCom.on(_service.eEventCommunication.RECEIVED_MASTER_MESSAGE, this.onServiceClusterReceived.bind(this));
+    await this.onServiceInit();
+    if (this.isMaster()) {
+      await this.onServiceMasterInit();
+    }
+    if (this.isCluster()) {
+      await this.onServiceClusterInit();
+    }
+  }
+  async onServiceInit() {
+    return;
+  }
+  async onServiceMasterInit() {
+    return;
+  }
+  async onServiceClusterInit() {
+    return;
+  }
+  sendToServiceCluster(clusterId, event, data) {
+    this.eCom.sendMessageToCluster(clusterId, event, data);
+  }
+  sendToServiceMaster(event, data) {
+    this.eCom.sendMessageToMaster(event, data);
+  }
+  onServiceMasterReceived(_worker, _eventKey, _data) {
+    return;
+  }
+  onServiceClusterReceived(_eventKey, _data) {
+    return;
+  }
+}
+var _default = exports.default = Service;

package/lib/app/classes/singleton.d.ts

@@ -0,0 +1,8 @@
+import { StaticSingleton } from '../../contracts/singleton';
+import Managed from './managed';
+declare abstract class Singleton extends Managed {
+    static instance: Singleton;
+    static singleton<S extends Singleton>(this: StaticSingleton<S>): S;
+}
+export default Singleton;
+//# sourceMappingURL=singleton.d.ts.map

package/lib/app/classes/singleton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singleton.d.ts","sourceRoot":"","sources":["../../../src/app/classes/singleton.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,OAAO,MAAM,WAAW,CAAC;AAWhC,uBAAe,SAAU,SAAQ,OAAO;IAEtC,MAAM,CAAC,QAAQ,EAAE,SAAS,CAAC;WAEb,SAAS,CAAC,CAAC,SAAS,SAAS,EAAE,IAAI,EAAE,eAAe,CAAC,CAAC,CAAC,GAE3C,CAAC;CAE5B;AAED,eAAe,SAAS,CAAC"}