outers
Version:
outers - a all in one package for your day to day use
160 lines • 9.12 kB
JavaScript
;
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
/* eslint-disable @typescript-eslint/no-explicit-any */
// main code for creating a cluster in node js
const node_os_1 = require("node:os"); // Import os module
const express_1 = __importDefault(require("express")); // Import express module
const ws_1 = require("ws"); // Import WebSocket module
const node_cluster_1 = __importDefault(require("node:cluster")); // Import Cluster module
const { isPrimary } = node_cluster_1.default; // Import isPrimary from Cluster
const Console_log_1 = require("../../Logs/Console.log"); // Import Console module
// Main Function
/**
* Configures and creates a cluster by function.
*
* @param ExpressServer - The main Express server instance.
* @param PORT - The port number to listen on.
* @param NumberOfWorkers - The number of worker copies to create.
* @param EnableTrustProxy - Whether to enable trust proxy or not.
* @param BeforeListenFunctions - Any functions to run before listening.
* @param AfterListenFunctions - Any functions to run after listening.
* @param FunctionMiddlewares - Any middlewares to apply to the Express server instance.
* @returns The response object containing the active server instance, active worker count, and responses from before listen functions.
* @throws Error if Express server, port, or number of workers is not provided.
*/
function SocketClusterConfig(ExpressServer = (0, express_1.default)(), // Main Express Server Instance
PORT = 3000, // Port Number to Listen
NumberOfWorkers = (0, node_os_1.cpus)().length, // Number of Copies of Workers
EnableTrustProxy = false, // Enable Trust Proxy
BeforeListenFunctions = [], // Any Functions to run before listen
AfterListenFunctions = [], // Any Functions to run after listen
FunctionMiddlewares = []) {
return __awaiter(this, void 0, void 0, function* () {
// Check if User Provided Express Server or not
if (!ExpressServer || ExpressServer === undefined) {
throw new Error("Express Server is not provided");
}
// Check if User Provided Port or not
if (!PORT || PORT === undefined) {
throw new Error("Port is not provided");
}
// Check if User Provided Number of Workers or not
if (!NumberOfWorkers || NumberOfWorkers === undefined) {
throw new Error("Number of Workers is not provided");
}
// Global Response Object
const GlobalResponseObject = {
ActiveServer: ExpressServer,
ActiveWorker: NumberOfWorkers,
TotalBeforeFunctions: BeforeListenFunctions.length,
TotalAfterFunctions: AfterListenFunctions.length,
ActiveMiddlewares: FunctionMiddlewares,
};
// Number of Workers to be forked
let ProcessCopy = NumberOfWorkers; // Copy Number of Workers
if (isPrimary) {
// If the cluster is the primary node
// Print CPU Count
(0, Console_log_1.bright)(`${(0, node_os_1.platform)()} ${(0, node_os_1.arch)()} server : ${((0, node_os_1.freemem)() /
1024 /
1024 /
1024).toFixed(2)} GB Free Ram : ${(0, node_os_1.cpus)()[0].model}`);
// Create a worker according to the number that is specified
while (ProcessCopy > 0) {
node_cluster_1.default.fork();
ProcessCopy--;
}
// Listen for Cluster Online
node_cluster_1.default.on("online", (worker) => {
(0, Console_log_1.green)(`🚀 Worker ${worker.process.pid} started 🚀`);
(0, Console_log_1.blue)(`Environment Variables Loaded Successfully in Worker : ${worker.process.pid}`);
GlobalResponseObject.ActiveWorker++; // Increment Active Worker Count by 1
(0, Console_log_1.yellow)(`Worker ${worker.process.pid} is listening`);
});
// Listen for Cluster Exit
node_cluster_1.default.on("exit", (worker) => {
(0, Console_log_1.red)(`Worker ${worker.process.pid} died`);
GlobalResponseObject.ActiveWorker++; // Increment Active Worker Count by 1
node_cluster_1.default.fork();
(0, Console_log_1.green)(`🚀 Worker ${worker.process.pid} restarted 🚀`);
(0, Console_log_1.blue)(`Environment Variables Loaded Successfully in Worker's variables : ${worker.process.pid}`);
GlobalResponseObject.ActiveWorker++; // Increment Active Worker Count by 1
(0, Console_log_1.yellow)(`Worker ${worker.process.pid} is listening`);
});
}
else {
// Enable trust proxy for Express Server
EnableTrustProxy
? ExpressServer.set("trust proxy", () => true)
: (0, Console_log_1.yellow)("Trust Proxy is not enabled, if you are working behind a proxy, please enable it to get the real IP Address");
// Apply Function Middlewares to Express Server Instance like CORS, Body Parser, etc.
if (FunctionMiddlewares.length > 0 || FunctionMiddlewares !== undefined) {
FunctionMiddlewares.forEach((FunctionMiddleware) => {
ExpressServer.use(FunctionMiddleware); // Apply Middleware to Express Server Instance one by one
}); // Apply Middlewares to Express Server Instance
}
// Run Before Listen Functions
if (BeforeListenFunctions.length > 0 ||
BeforeListenFunctions !== undefined) {
for (const ListenFunction of BeforeListenFunctions) {
yield ListenFunction(); // Run Before Listen Functions one by one
}
}
// Server Listen
try {
const ActiveServer = ExpressServer.listen(PORT, () => __awaiter(this, void 0, void 0, function* () {
(0, Console_log_1.green)(`🚀 Server is listening on Port ${PORT} 🚀`); // Print Message for Server Start
// Run After Listen Functions
if (AfterListenFunctions.length > 0 ||
AfterListenFunctions !== undefined) {
for (const ListenFunction of AfterListenFunctions) {
yield ListenFunction(); // Run Function one by one
}
}
})); // Start Server on Port
// Create WebSocket server
const WebSocketServerInstance = new ws_1.WebSocketServer({
server: ActiveServer,
});
// WebSocket connection handler
WebSocketServerInstance.on("connection", (ws) => {
(0, Console_log_1.green)("WebSocket client connected");
ws.on("message", (message) => {
(0, Console_log_1.blue)(`Received message: ${message}`);
});
ws.on("close", () => {
(0, Console_log_1.red)("WebSocket client disconnected");
});
});
// Return the Active Server Instance in Response Object
GlobalResponseObject.ActiveServer = ActiveServer; // Active Server Instance After Listen
return Object.freeze(GlobalResponseObject); // Return Response Object to User for further use
}
catch (error) {
(0, Console_log_1.red)(`Error in Starting Server : ${error}`); // Print Error Message for Server Start
return Object.freeze({
Error: error,
ActiveServer: GlobalResponseObject.ActiveServer,
ActiveWorker: GlobalResponseObject.ActiveWorker,
TotalBeforeFunctions: GlobalResponseObject.TotalBeforeFunctions,
TotalAfterFunctions: GlobalResponseObject.TotalAfterFunctions,
ActiveMiddlewares: GlobalResponseObject.ActiveMiddlewares,
}); // Return Error to User
}
}
});
}
exports.default = SocketClusterConfig;
//# sourceMappingURL=CreateSocketClusterByFunction.method.js.map