@colyseus/tools 0.15.43 → 0.15.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colyseus/tools",
-  "version": "0.15.43",
+  "version": "0.15.45",
   "description": "Colyseus Tools for Production",
   "input": "./src/index.ts",
   "main": "./build/index.js",
@@ -31,24 +31,33 @@
     "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",
     "node-os-utils": "^1.3.7",
     "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/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();