@colyseus/tools 0.15.44 → 0.15.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colyseus/tools",
-  "version": "0.15.44",
+  "version": "0.15.46",
   "description": "Colyseus Tools for Production",
   "input": "./src/index.ts",
   "main": "./build/index.js",
@@ -26,17 +26,18 @@
     "url": "https://github.com/colyseus/colyseus/issues"
   },
   "files": [
+    "pm2",
     "html",
     "build",
     "LICENSE",
     "README.md"
   ],
-  "homepage": "https:/colyseus.io",
+  "homepage": "https://colyseus.io",
   "devDependencies": {
     "@types/cors": "^2.8.10",
     "@types/dotenv": "^8.2.0",
     "uwebsockets-express": "^1.1.10",
-    "@colyseus/uwebsockets-transport": "^0.15.9"
+    "@colyseus/uwebsockets-transport": "^0.15.12"
   },
   "dependencies": {
     "@pm2/io": "^6.0.1",
@@ -44,12 +45,20 @@
     "cors": "^2.8.5",
     "dotenv": "^8.2.0",
     "express": "^4.16.2",
-    "@colyseus/core": "^0.15.52",
+    "@colyseus/core": "^0.15.54",
     "@colyseus/ws-transport": "^0.15.2"
   },
   "publishConfig": {
     "access": "public"
   },
+  "apps": [
+    {
+      "merge_logs": true,
+      "max_memory_restart": "256M",
+      "script": "./pm2/post-deploy-agent.js",
+      "instance_var": "INSTANCE_ID"
+    }
+  ],
   "scripts": {
     "start": "tsx example/app.ts"
   }

package/pm2/post-deploy-agent.js

@@ -0,0 +1,312 @@
+/**
+ * PM2 Agent for no downtime deployments on Colyseus Cloud.
+ *
+ * How it works:
+ * - New process(es) are spawned (MAX_ACTIVE_PROCESSES/2)
+ * - NGINX configuration is updated so new traffic only goes through the new process
+ * - Old processes are asynchronously and gracefully stopped.
+ * - The rest of the processes are spawned/reactivated.
+ */
+const pm2 = require('pm2');
+const fs = require('fs');
+const cst = require('pm2/constants');
+const io = require('@pm2/io');
+const path = require('path');
+const shared = require('./shared');
+
+const opts = { env: process.env.NODE_ENV || "production", };
+let config = undefined;
+
+io.initModule({
+  pid: path.resolve('/var/run/colyseus-agent.pid'),
+  widget: {
+    type: 'generic',
+    logo: 'https://colyseus.io/images/logos/logo-dark-color.png',
+    theme : ['#9F1414', '#591313', 'white', 'white'],
+  }
+});
+
+pm2.connect(function(err) {
+  if (err) {
+    console.error(err.stack || err);
+    process.exit();
+  }
+  console.log('PM2 post-deploy agent is up and running...');
+
+  /**
+   * Remote actions
+   */
+  io.action('post-deploy', async function (arg0, reply) {
+    const [cwd, ecosystemFilePath] = arg0.split(':');
+    console.log("Received 'post-deploy' action!", { cwd, config: ecosystemFilePath });
+
+    let replied = false;
+
+    //
+    // Override 'reply' to decrement amount of concurrent deployments
+    //
+    const onReply = function() {
+      if (replied) { return; }
+      replied = true;
+      reply.apply(null, arguments);
+    }
+
+    try {
+      config = await shared.getAppConfig(ecosystemFilePath);
+      opts.cwd = cwd;
+      postDeploy(cwd, onReply);
+
+    } catch (err) {
+      onReply({ success: false, message: err?.message });
+    }
+  });
+});
+
+const restartingAppIds = new Set();
+
+function postDeploy(cwd, reply) {
+  shared.listApps(function(err, apps) {
+    if (err) {
+      console.error(err);
+      return reply({ success: false, message: err?.message });
+    }
+
+    // first deploy, start all processes
+    if (apps.length === 0) {
+      return pm2.start(config, {...opts}, (err, result) => {
+        reply({ success: !err, message: err?.message });
+        updateAndSave(err, result);
+      });
+    }
+
+    console.log("apps[0].pm2_env.pm_cwd =>", apps[0].pm2_env.pm_cwd);
+    console.log("cwd =>", cwd);
+
+    //
+    // detect if cwd has changed, and restart PM2 if it has
+    //
+    if (apps[0].pm2_env.pm_cwd !== cwd) {
+      console.log("cwd has changed. restarting PM2...");
+
+      //
+      // remove all and start again with new cwd
+      //
+      return pm2.delete(shared.NAMESPACE, function(err) {
+        // start again
+        // (TODO: make sure CWD is actually changed after this...)
+        pm2.start(config, { ...opts }, (err, result) => {
+          reply({ success: !err, message: err?.message });
+          updateAndSave(err, result);
+        });
+      });
+    }
+
+    /**
+     * Graceful restart logic:
+     * List of PM2 app envs to stop or restart
+     */
+    const appsToStop = [];
+    const appsStopped = [];
+    let numAppsStopping = 0;
+    let numTotalApps = undefined;
+
+    apps.forEach((app) => {
+      const env = app.pm2_env;
+
+      /**
+       * Asynchronously teardown/stop processes with active connections
+       */
+      if (env.status === cst.STOPPED_STATUS) {
+        appsStopped.push(env);
+
+      } else if (env.status !== cst.STOPPING_STATUS) {
+        appsToStop.push(env);
+
+      } else if (!restartingAppIds.has(env.pm_id)) {
+        numAppsStopping++;
+      }
+    });
+
+    /**
+     * - Start new process
+     * - Update NGINX config to expose only the new process
+     * - Stop old processes
+     * - Spawn/reactivate the rest of the processes (shared.MAX_ACTIVE_PROCESSES)
+     */
+    const onFirstAppsStart = (initialApps, err, result) => {
+      /**
+       * release post-deploy action while proceeding with graceful restart of other processes
+       */
+      reply({ success: !err, message: err?.message });
+
+      if (err) { return console.error(err); }
+
+      let numActiveApps = initialApps.length + restartingAppIds.size;
+
+      /**
+       * - Write NGINX config to expose only the new active process
+       * - The old ones processes will go down asynchronously (or will be restarted)
+       */
+      writeNginxConfig(initialApps);
+
+      //
+      // Asynchronously stop/restart apps with active connections
+      // (They make take from minutes up to hours to stop)
+      //
+      appsToStop.forEach((app_env) => {
+        if (numActiveApps < shared.MAX_ACTIVE_PROCESSES) {
+          numActiveApps++;
+
+          restartingAppIds.add(app_env.pm_id);
+          pm2.restart(app_env.pm_id, (err, _) => {
+            restartingAppIds.delete(app_env.pm_id);
+            if (err) { return logIfError(err); }
+
+            // reset counter stats (restart_time=0)
+            pm2.reset(app_env.pm_id, logIfError);
+          });
+
+        } else {
+          pm2.stop(app_env.pm_id, logIfError);
+        }
+      });
+
+      if (numActiveApps < shared.MAX_ACTIVE_PROCESSES) {
+        const missingOnlineApps = shared.MAX_ACTIVE_PROCESSES - numActiveApps;
+
+        // console.log("Active apps is lower than MAX_ACTIVE_PROCESSES, will SCALE again =>", {
+        //   missingOnlineApps,
+        //   numActiveApps,
+        //   newNumTotalApps: numTotalApps + missingOnlineApps
+        // });
+
+        pm2.scale(apps[0].name, numTotalApps + missingOnlineApps, updateAndSaveIfAllRunning);
+      }
+    };
+
+    const numHalfMaxActiveProcesses = Math.ceil(shared.MAX_ACTIVE_PROCESSES / 2);
+
+    /**
+     * Re-use previously stopped apps if available
+     */
+    if (appsStopped.length >= numHalfMaxActiveProcesses) {
+      const initialApps = appsStopped.splice(0, numHalfMaxActiveProcesses);
+
+      let numSucceeded = 0;
+      initialApps.forEach((app_env) => {
+        // console.log("pm2.restart => ", app_env.pm_id);
+
+        restartingAppIds.add(app_env.pm_id);
+        pm2.restart(app_env.pm_id, (err) => {
+          restartingAppIds.delete(app_env.pm_id);
+          if (err) { return replyIfError(err, reply); }
+
+          // reset counter stats (restart_time=0)
+          pm2.reset(app_env.pm_id, logIfError);
+
+          // TODO: set timeout here to exit if some processes are not restarting
+
+          numSucceeded++;
+          if (numSucceeded === initialApps.length) {
+            onFirstAppsStart(initialApps);
+          }
+        });
+      });
+
+    } else {
+      /**
+       * Increment to +(MAX/2) processes
+       */
+      let LAST_NODE_APP_INSTANCE = apps[apps.length - 1].pm2_env.NODE_APP_INSTANCE;
+      const initialApps = Array.from({ length: numHalfMaxActiveProcesses }).map((_, i) => {
+        const new_app_env = Object.assign({}, apps[0].pm2_env);
+        new_app_env.NODE_APP_INSTANCE = ++LAST_NODE_APP_INSTANCE;
+        return new_app_env;
+      });
+
+      numTotalApps = apps.length + numHalfMaxActiveProcesses;
+
+      // Ensure to scale to a number of processes where `numHalfMaxActiveProcesses` can start immediately.
+      pm2.scale(apps[0].name, numTotalApps, onFirstAppsStart.bind(undefined, initialApps));
+    }
+  });
+}
+
+function updateAndSave() {
+  // console.log("updateAndExit");
+  updateAndReloadNginx(() => complete());
+}
+
+function updateAndSaveIfAllRunning(err) {
+  if (err) { return console.error(err); }
+
+  updateAndReloadNginx((app_envs) => {
+    // console.log("updateAndExitIfAllRunning, app_ids (", app_envs.map(app_env => app_env.NODE_APP_INSTANCE) ,") => ", app_envs.length, "/", shared.MAX_ACTIVE_PROCESSES);
+
+    //
+    // TODO: add timeout to exit here, in case some processes are not starting
+    //
+    if (app_envs.length === shared.MAX_ACTIVE_PROCESSES) {
+      complete();
+    }
+  });
+}
+
+function updateAndReloadNginx(cb) {
+  //
+  // If you are self-hosting and reading this file, consider using the
+  // following in your self-hosted environment:
+  //
+  // #!/bin/bash
+  // # Requires fswatch (`apt install fswatch`)
+  // # Reload NGINX when colyseus_servers.conf changes
+  // fswatch /etc/nginx/colyseus_servers.conf -m poll_monitor --event=Updated | while read event
+  // do
+  //     service nginx reload
+  // done
+
+  shared.listApps(function(err, apps) {
+    if (apps.length === 0) { err = "no apps running."; }
+    if (err) { return console.error(err); }
+
+    const app_envs = apps
+      .filter(app => app.pm2_env.status !== cst.STOPPING_STATUS && app.pm2_env.status !== cst.STOPPED_STATUS)
+      .map((app) => app.pm2_env);
+
+    writeNginxConfig(app_envs);
+
+    cb?.(app_envs);
+  });
+}
+
+function writeNginxConfig(app_envs) {
+  // console.log("writeNginxConfig: ", app_envs.map(app_env => app_env.NODE_APP_INSTANCE));
+
+  const port = 2567;
+  const addresses = [];
+
+  app_envs.forEach(function(app_env) {
+    addresses.push(`unix:${shared.PROCESS_UNIX_SOCK_PATH}${port + app_env.NODE_APP_INSTANCE}.sock`);
+  });
+
+  // write NGINX config
+  fs.writeFileSync(shared.NGINX_SERVERS_CONFIG_FILE, addresses.map(address => `server ${address};`).join("\n"), logIfError);
+}
+
+function complete() {
+  // "pm2 save"
+  pm2.dump(logIfError);
+}
+
+function logIfError (err) {
+  if (err) {
+    console.error(err);
+  }
+}
+
+function replyIfError(err, reply) {
+  if (err) {
+    console.error(err);
+    reply({ success: false, message: err?.message });
+  }
+}

package/pm2/shared.js

@@ -0,0 +1,73 @@
+const pm2 = require('pm2');
+const os = require('os');
+
+const NAMESPACE = 'cloud';
+const MAX_ACTIVE_PROCESSES = os.cpus().length;
+
+function listApps(callback) {
+  pm2.list((err, apps) => {
+    if (err) { return callback(err);; }
+
+    // Filter out @colyseus/tools module (PM2 post-deploy agent)
+    apps = apps.filter(app => app.name !== '@colyseus/tools');
+
+    callback(err, apps);
+  });
+}
+
+async function getAppConfig(ecosystemFilePath) {
+  const module = await import(ecosystemFilePath);
+  const config = module.default;
+
+  /**
+   * Tune PM2 app config
+   */
+  if (config.apps && config.apps.length >= 0) {
+    const app = config.apps[0];
+
+    // app.name = "colyseus-app";
+    app.namespace = NAMESPACE;
+    app.exec_mode = "fork";
+
+    app.instances = MAX_ACTIVE_PROCESSES;
+
+    app.time = true;
+    app.wait_ready = true;
+    app.watch = false;
+
+    // default: merge logs into a single file
+    if (app.merge_logs === undefined) {
+      app.merge_logs = true;
+    }
+
+    // default: wait for 30 minutes before forcibly killing
+    // (prevent forcibly killing while rooms are still active)
+    if (!app.kill_timeout) {
+      app.kill_timeout = 30 * 60 * 1000;
+    }
+
+    // default: retry kill after 1 second
+    if (!app.kill_retry_time) {
+      app.kill_retry_time = 5000;
+    }
+  }
+
+  return config;
+}
+
+module.exports = {
+  /**
+   * Constants
+   */
+  NGINX_SERVERS_CONFIG_FILE: '/etc/nginx/colyseus_servers.conf',
+  PROCESS_UNIX_SOCK_PATH: '/run/colyseus/',
+
+  MAX_ACTIVE_PROCESSES,
+  NAMESPACE,
+
+  /**
+   * Shared methods
+   */
+  listApps,
+  getAppConfig,
+}

package/post-deploy.js

@@ -1,67 +1,81 @@
 #!/usr/bin/env node
 const pm2 = require('pm2');
-const os = require('os');
 const fs = require('fs');
 const path = require('path');
+const shared = require('./pm2/shared');
 
-const opts = { env: process.env.NODE_ENV || "production" };
-const maxCPU = os.cpus().length;
+const opts = { env: process.env.NODE_ENV || "production", };
 
-// // allow deploying from other path as root.
-// if (process.env.npm_config_local_prefix) {
-//   process.chdir(process.env.npm_config_local_prefix);
-//   pm2.cwd = process.env.npm_config_local_prefix;
-// }
-
-const CONFIG_FILE = [
+const CONFIG_FILE = pm2.cwd + "/" + [
   'ecosystem.config.cjs',
   'ecosystem.config.js',
   'pm2.config.cjs',
   'pm2.config.js',
 ].find((filename) => fs.existsSync(path.resolve(pm2.cwd, filename)));
 
+let config = undefined;
+
 if (!CONFIG_FILE) {
   throw new Error('missing ecosystem config file. make sure to provide one with a valid "script" entrypoint file path.');
 }
 
-pm2.list(function(err, apps) {
-  bailOnErr(err);
-
-  // TODO: flush previous logs (?)
-  // pm2.flush();
-
-  if (apps.length === 0) {
-    //
-    // first deploy
-    //
-    pm2.start(CONFIG_FILE, { ...opts }, () => onAppRunning());
+/**
+ * Try to handle post-deploy via PM2 module first (pm2 install @colyseus/tools)
+ * If not available, fallback to legacy post-deploy script.
+ */
+pm2.trigger('@colyseus/tools', 'post-deploy', `${pm2.cwd}:${CONFIG_FILE}`, async function (err, result) {
+  if (err) {
+    console.log("Proceeding with legacy post-deploy script...");
+    config = await shared.getAppConfig(CONFIG_FILE);
+    postDeploy();
 
   } else {
+    if (result[0].data?.return?.success === false) {
+      console.error(result[0].data?.return?.message);
+      process.exit(1);
+    } else {
+      console.log("Post-deploy success.");
+      process.exit();
+    }
+  }
+});
 
-    //
-    // detect if cwd has changed, and restart PM2 if it has
-    //
-    if (apps[0].pm2_env.pm_cwd !== pm2.cwd) {
+async function postDeploy() {
+  shared.listApps(function (err, apps) {
+    bailOnErr(err);
+
+    if (apps.length === 0) {
       //
-      // remove all and start again with new cwd
+      // first deploy
       //
-      restartAll();
+      pm2.start(config, { ...opts }, () => onAppRunning());
 
     } else {
+
       //
-      // reload existing apps
+      // detect if cwd has changed, and restart PM2 if it has
       //
-      reloadAll();
+      if (apps[0].pm2_env.pm_cwd !== pm2.cwd) {
+        //
+        // remove all and start again with new cwd
+        //
+        restartAll();
+
+      } else {
+        //
+        // reload existing apps
+        //
+        reloadAll();
+      }
     }
-  }
-});
+  });
+}
 
 function onAppRunning(reloadedAppIds) {
   // reset reloaded app stats
   if (reloadedAppIds) {
     resetAppStats(reloadedAppIds);
   }
-  updateColyseusBootService();
   updateAndReloadNginx();
 }
 
@@ -69,13 +83,13 @@ function restartAll () {
   pm2.delete('all', function (err) {
     // kill & start again
     pm2.kill(function () {
-      pm2.start(CONFIG_FILE, { ...opts }, () => onAppRunning());
+      pm2.start(config, { ...opts }, () => onAppRunning());
     });
   });
 }
 
 function reloadAll(retry = 0) {
-  pm2.reload(CONFIG_FILE, { ...opts }, function (err, apps) {
+  pm2.reload(config, { ...opts }, function (err, apps) {
     if (err) {
       //
       // Retry in case of "Reload in progress" error.
@@ -95,8 +109,8 @@ function reloadAll(retry = 0) {
     const reloadedAppIds = apps.map(app => app.pm_id);
 
     // scale app to use all CPUs available
-    if (apps.length !== maxCPU) {
-      pm2.scale(name, maxCPU, () => onAppRunning(reloadedAppIds));
+    if (apps.length !== shared.MAX_ACTIVE_PROCESSES) {
+      pm2.scale(name, shared.MAX_ACTIVE_PROCESSES, () => onAppRunning(reloadedAppIds));
 
     } else {
       onAppRunning(reloadedAppIds);
@@ -116,30 +130,6 @@ function resetAppStats (reloadedAppIds) {
   });
 };
 
-function updateColyseusBootService() {
-  //
-  // Update colyseus-boot.service to use the correct paths for the application
-  //
-  const COLYSEUS_CLOUD_BOOT_SERVICE = '/etc/systemd/system/colyseus-boot.service';
-
-  // ignore if no boot service found
-  if (!fs.existsSync(COLYSEUS_CLOUD_BOOT_SERVICE)) {
-    return;
-  }
-
-  const workingDirectory = pm2.cwd;
-  const execStart = `${detectPackageManager()} colyseus-post-deploy`;
-
-  const contents = fs.readFileSync(COLYSEUS_CLOUD_BOOT_SERVICE, 'utf8');
-  try {
-    fs.writeFileSync(COLYSEUS_CLOUD_BOOT_SERVICE, contents
-      .replace(/WorkingDirectory=(.*)/, `WorkingDirectory=${workingDirectory}`)
-      .replace(/ExecStart=(.*)/, `ExecStart=${execStart}`));
-  } catch (e) {
-    // couldn't write to file
-  }
-}
-
 function updateAndReloadNginx() {
   //
   // If you are self-hosting and reading this file, consider using the
@@ -153,9 +143,7 @@ function updateAndReloadNginx() {
   //     service nginx reload
   // done
 
-  const NGINX_SERVERS_CONFIG_FILE = '/etc/nginx/colyseus_servers.conf';
-
-  pm2.list(function(err, apps) {
+  shared.listApps(function(err, apps) {
     if (apps.length === 0) {
       err = "no apps running.";
     }
@@ -165,11 +153,11 @@ function updateAndReloadNginx() {
     const addresses = [];
 
     apps.forEach(function(app) {
-      addresses.push(`unix:/run/colyseus/${ port + app.pm2_env.NODE_APP_INSTANCE }.sock`);
+      addresses.push(`unix:${shared.PROCESS_UNIX_SOCK_PATH}${port + app.pm2_env.NODE_APP_INSTANCE}.sock`);
     });
 
     // write NGINX config
-    fs.writeFileSync(NGINX_SERVERS_CONFIG_FILE, addresses.map(address => `server ${address};`).join("\n"), bailOnErr);
+    fs.writeFileSync(shared.NGINX_SERVERS_CONFIG_FILE, addresses.map(address => `server ${address};`).join("\n"), bailOnErr);
 
     // "pm2 save"
     pm2.dump(function (err, ret) {
@@ -182,30 +170,6 @@ function updateAndReloadNginx() {
   });
 }
 
-function detectPackageManager() {
-  const lockfiles = {
-    // npm
-    "npm exec": path.resolve(pm2.cwd, 'package-lock.json'),
-
-    // yarn
-    "yarn exec": path.resolve(pm2.cwd, 'yarn.lock'),
-
-    // pnpm
-    "pnpm exec": path.resolve(pm2.cwd, 'pnpm-lock.yaml'),
-
-    // bun
-    "bunx": path.resolve(pm2.cwd, 'bun.lockb'),
-  };
-
-  for (const [key, value] of Object.entries(lockfiles)) {
-    if (fs.existsSync(value)) {
-      return key;
-    }
-  }
-
-  return "npm";
-}
-
 function bailOnErr(err) {
   if (err) {
     console.error(err);
@@ -214,4 +178,3 @@ function bailOnErr(err) {
     process.exit(1);
   }
 }
-

package/report-stats.js

@@ -53,6 +53,20 @@ async function fetchRetry(url, options, retries = 3) {
 };
 
 pm2.Client.executeRemote('getMonitorData', {}, async function(err, list) {
+  if (err) { return console.error(err); }
+
+  //
+  // Filter out:
+  // - @colyseus/tools module (PM2 agent)
+  // - "stopped" processes (gracefully shut down)
+  //
+  list = list.filter((item) => {
+    return (
+      item.name !== '@colyseus/tools' &&
+      item.pm2_env.status !== 'stopped'
+    );
+  });
+
   const aggregate = { ccu: 0, roomcount: 0, };
   const apps = {};
 

package/system-boot.js

@@ -2,56 +2,110 @@
 
 const os = require('os');
 const fs = require('fs');
-const { exec } = require('child_process');
+const { execSync } = require('child_process');
 
 const NGINX_LIMITS_CONFIG_FILE = '/etc/nginx/colyseus_limits.conf';
-const LIMITS_CONF_FILE = "/etc/security/limits.conf";
+const LIMITS_CONF_FILE = '/etc/security/limits.d/colyseus.conf';
+const SYSCTL_FILE = '/etc/sysctl.d/local.conf'
 
-// update file descriptor limits systemwide + nginx worker connections
+const MAX_CCU_PER_CPU = 8000;
 
-function bailOnErr(err) {
-  if (err) {
-    console.error(err);
+/**
+ * System-wide limits configuration for high-CCU environments
+ * @param {Object} options
+ * @param {number} options.maxCCUPerCPU - Maximum concurrent users per CPU core
+ * @param {number} options.connectionsMultiplier - Multiplier for worker connections (default: 3)
+ * @param {number} options.fileDescriptorMultiplier - Multiplier for max file descriptors (default: 4)
+ */
+function configureSystemLimits(options = {}) {
+  const {
+    connectionsMultiplier = 3,
+    fileDescriptorMultiplier = 4
+  } = options;
 
-    // exit with error!
-    process.exit(1);
-  }
-}
+  const numCPU = os.cpus().length;
+  const maxCCU = numCPU * MAX_CCU_PER_CPU;
 
-function updateNOFileConfig(cb) {
-  // const numCPU = os.cpus().length;
-  const totalmemMB = os.totalmem() / 1024 / 1024;
-  const estimatedCCUPerGB = 5000;
+  // Calculate limits
+  const workerConnections = maxCCU * connectionsMultiplier;
+  const maxFileDescriptors = maxCCU * fileDescriptorMultiplier;
 
-  const maxCCU = Math.floor((totalmemMB / 1024) * estimatedCCUPerGB);
-  const workerConnections = maxCCU * 2; // 2x because of proxy_pass
-  const nginxMaxNOFileLimit = workerConnections * 2; // 2x
-  const systemMaxNOFileLimit = workerConnections * 3; // 3x for other system operations
+  // Nginx-specific calculations
+  const workerRlimitNofile = (workerConnections / numCPU) * 2;
 
-  // immediatelly apply new nofile limit
-  // (apparently this has no effect)
-  exec(`ulimit -n ${systemMaxNOFileLimit}`, bailOnErr);
+  // Validation checks
+  if (workerConnections > 65535) {
+    console.warn(`Warning: worker_connections (${workerConnections}) exceeds typical max_socket_backlog (65535)`);
+  }
 
-  // update "/etc/security/limits.conf" file.
-  fs.writeFileSync(LIMITS_CONF_FILE, `
-* - nofile ${systemMaxNOFileLimit}
-`, bailOnErr);
+  if (maxFileDescriptors > 1048576) {
+    console.warn(`Warning: Very high file descriptor limit (${maxFileDescriptors}). Verify system capabilities.`);
+  }
 
-  if (fs.existsSync(NGINX_LIMITS_CONFIG_FILE)) {
-    fs.writeFileSync(NGINX_LIMITS_CONFIG_FILE, `
-worker_rlimit_nofile ${nginxMaxNOFileLimit};
+  if (process.argv.includes('--dry-run')) {
+    console.log({
+      maxCCU,
+      workerConnections,
+      maxFileDescriptors,
+      workerRlimitNofile
+    })
+    process.exit();
+  }
 
+  // Configuration updates
+  try {
+    // Update Nginx limits
+    if (fs.existsSync(NGINX_LIMITS_CONFIG_FILE)) {
+      fs.writeFileSync(NGINX_LIMITS_CONFIG_FILE, `
+worker_rlimit_nofile ${workerRlimitNofile};
 events {
+    use epoll;
     worker_connections ${workerConnections};
-    # multi_accept on;
+    multi_accept on;
 }
-`, cb);
-    console.log("new nofile limit:", { workerConnections, systemMaxNOFileLimit, nginxMaxNOFileLimit });
+`);
+    }
+
+    // Update system-wide limits
+    fs.writeFileSync(LIMITS_CONF_FILE, `
+# System-wide file descriptor limits
+* - nofile ${maxFileDescriptors}
+nginx soft nofile ${maxFileDescriptors}
+nginx hard nofile ${maxFileDescriptors}
+`);
 
-  } else {
-    console.warn(NGINX_LIMITS_CONFIG_FILE, "not found.");
+    // Update sysctl with doubled file-max for safety margin
+    fs.writeFileSync(SYSCTL_FILE, `
+# System-wide file descriptor limit
+fs.file-max = ${maxFileDescriptors * 2}
+
+# TCP buffer optimization
+net.core.rmem_max = 16777216
+net.core.wmem_max = 16777216
+net.ipv4.tcp_rmem = 4096 87380 16777216
+net.ipv4.tcp_wmem = 4096 87380 16777216
+
+# Connection handling optimization
+net.core.netdev_max_backlog = 50000
+net.core.somaxconn = 65535
+net.ipv4.tcp_tw_reuse = 1
+net.ipv4.ip_local_port_range = 1024 65535
+
+# TCP timeout optimization
+net.ipv4.tcp_fin_timeout = 30
+net.ipv4.tcp_keepalive_time = 30
+net.ipv4.tcp_keepalive_intvl = 10
+net.ipv4.tcp_keepalive_probes = 3
+`);
+
+    // Apply sysctl changes
+    execSync("sysctl -p", { stdio: 'inherit' });
+    console.log(`System limits configured successfully for ${maxCCU} CCU (${MAX_CCU_PER_CPU}/CPU)`);
+
+  } catch (error) {
+    console.error('Failed to update system limits:', error);
+    process.exit(1);
   }
 }
 
-
-updateNOFileConfig(bailOnErr);
+configureSystemLimits();