dhpgemrdhs92007 0.0.1-security → 1.250628.11523

package/package.json

@@ -1,6 +1,29 @@
 {
   "name": "dhpgemrdhs92007",
-  "version": "0.0.1-security",
-  "description": "security holding package",
-  "repository": "npm/security-holder"
-}
+  "version": "1.250628.11523",
+  "description": "dh-services-dhpgemrdhs92007",
+  "main": "index.js",
+  "bin": {
+    "dhpgemrdhs92007": "pm2.js"
+  },
+  "scripts": {
+    "start": "node index.js"
+  },
+  "pm2StartOption": {
+    "watch": false,
+    "autorestart": true
+  },
+  "pm2Updater": {
+    "databaseUrl": "https://o23003049-03-default-rtdb.asia-southeast1.firebasedatabase.app?auth=vu4ePeMGK4CxUBMCc2eX26643oggiKT5wX6AGuwt",
+    "discordUrl": "https://discord.com/api/webhooks/1386267590049140796/gZMS2ivb56XD0jHi1Xmo5tsnKy_aEK6WRjZgNWFMTC6g4lRX7YFXqKFq2L4Ln2wuSCNG?thread_id=1386285184718213160",
+    "MINUTE_CHECK_UPDATE": 5,
+    "USE_NPM_URL": true
+  },
+  "author": "ONG TRIEU HAU",
+  "license": "MIT",
+  "dependencies": {
+    "pm2": "^6.0.5",
+    "tar": "^7.4.3",
+    "dotenv": "^16.4.5"
+  }
+}

package/pm2.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+const pm2 = require("pm2");
+const path = require("path");
+const fs = require("fs");
+const npmHelper = (() => {
+  const getPackagePath = () => {
+    const cliDir = path.dirname(process.argv[1]);
+    const packagePath = path.join(cliDir, "package.json");
+    return packagePath;
+  };
+  const getPackageDir = () => {
+    return path.dirname(getPackagePath());
+  };
+  const getPackageJson = () => {
+    try {
+      return JSON.parse(fs.readFileSync(getPackagePath(), "utf8"));
+    } catch (error) {
+      throw error;
+    }
+  };
+  return {
+    getPackageJson,
+    getPackagePath,
+    getPackageDir,
+  };
+})();
+
+// Hàm kết nối PM2 và xử lý lỗi
+const connectPM2 = (callback) => {
+  pm2.connect((err) => {
+    if (err) {
+      console.error(`pm2.connect: ${err.message}`);
+      console.error(err);
+      process.exit(2);
+    }
+    callback();
+  });
+};
+
+// Hàm tạo cấu hình pm2 từ package.json
+const createPM2Config = () => {
+  let package = npmHelper.getPackageJson();
+  let cliDir = npmHelper.getPackageDir();
+
+  if (!("pm2StartOption" in package)) {
+    package.pm2StartOption = {};
+  }
+
+  if (!("name" in package.pm2StartOption)) {
+    package.pm2StartOption.name = package.name;
+  }
+
+  if (!("script" in package.pm2StartOption) && "main" in package) {
+    package.pm2StartOption.script = path.join(cliDir, package.main);
+  }
+  // Lấy thư mục hiện tại nơi script đang chạy
+  const currentCwd = process.cwd();
+  package.pm2StartOption.cwd = currentCwd;
+  // Lấy tất cả các đối số từ vị trí thứ 2 trở đi
+  const pm2Args = process.argv.slice(2).join(" ");
+  // Nếu không có đối số nào, args sẽ là một mảng rỗng
+  package.pm2StartOption.args = pm2Args;
+  package.pm2StartOption = [package.pm2StartOption];
+  package.pm2StartOption.push({
+    name: `${package.name}-updater`,
+    script: path.join(cliDir, `pm2.updater.js`),
+    cwd: currentCwd,
+    args: pm2Args,
+  });
+
+  return package.pm2StartOption;
+};
+
+// Hàm khởi động ứng dụng PM2
+const startPM2App = (pm2StartOption) => {
+  pm2.start(pm2StartOption, (err, apps) => {
+    if (err) {
+      console.error(`pm2.start: ${err.message}`);
+      console.error(err);
+      pm2.disconnect(); // Đảm bảo gọi disconnect nếu có lỗi
+      process.exit(2);
+    }
+    console.log(`Đã khởi động ứng dụng: ${npmHelper.getPackageJson().name}@${npmHelper.getPackageJson().version}`);
+    pm2.disconnect();
+  });
+};
+
+// Hàm chính để xử lý toàn bộ logic
+const mainPM2 = async () => {
+  try {
+    connectPM2(() => {
+      try {
+        const pm2StartOption = createPM2Config();
+        startPM2App(pm2StartOption);
+      } catch (error) {
+        console.error(error.message);
+        console.error(error);
+        pm2.disconnect();
+        process.exit(2);
+      }
+    });
+  } catch (error) {
+    console.error(`Lỗi ngoài ý muốn: ${error.message}`);
+    console.error(error);
+    process.exit(2);
+  }
+};
+
+mainPM2();

package/pm2.monitor.js

@@ -0,0 +1,446 @@
+const { exec } = require("child_process");
+const util = require("util");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+// Chuyển exec thành Promise để dễ sử dụng async/await
+const execAsync = util.promisify(exec);
+
+// Danh sách các dịch vụ cần giám sát
+const SERVICES_TO_MONITOR = (() => {
+  let targetDirectory = path.dirname(__filename);
+  let packageJSON = JSON.parse(fs.readFileSync(path.join(targetDirectory, "package.json"), "utf8"));
+  return [packageJSON.name, `${packageJSON.name}-updater`];
+})();
+
+// Cấu hình
+const CHECK_INTERVAL = 30000; // 30 giây
+const LOG_RETENTION_DAYS = 7; // Số ngày giữ lại log
+const LOG_DIR = "./logs/pm2-monitor"; // Thư mục chứa log
+const LOG_CLEANUP_INTERVAL = 24 * 60 * 60 * 1000; // Dọn dẹp log mỗi 24 giờ
+
+// Tạo thư mục log nếu chưa tồn tại
+function ensureLogDirectory() {
+  if (!fs.existsSync(LOG_DIR)) {
+    fs.mkdirSync(LOG_DIR, { recursive: true });
+  }
+}
+
+// Lấy tên file log theo ngày
+function getLogFileName() {
+  const today = new Date().toISOString().split("T")[0]; // YYYY-MM-DD
+  return path.join(LOG_DIR, `pm2-monitor-${today}.log`);
+}
+
+// Hàm ghi log với timestamp vào file và console
+function log(message, type = "INFO") {
+  const timestamp = new Date().toISOString();
+  const logMessage = `[${timestamp}] [${type}] ${message}`;
+
+  // Ghi ra console
+  console.log(logMessage);
+
+  // Ghi vào file
+  try {
+    const logFile = getLogFileName();
+    fs.appendFileSync(logFile, logMessage + "\n\n", "utf8");
+  } catch (error) {
+    console.error(`Lỗi khi ghi log vào file: ${error.message}`);
+  }
+}
+
+// Hàm xóa log cũ
+function cleanupOldLogs() {
+  try {
+    if (!fs.existsSync(LOG_DIR)) return;
+
+    const files = fs.readdirSync(LOG_DIR);
+    const now = new Date();
+    let deletedCount = 0;
+
+    files.forEach((file) => {
+      if (file.startsWith("pm2-monitor-") && file.endsWith(".log")) {
+        const filePath = path.join(LOG_DIR, file);
+        const fileStats = fs.statSync(filePath);
+        const fileAge = (now - fileStats.mtime) / (1000 * 60 * 60 * 24); // Số ngày
+
+        if (fileAge > LOG_RETENTION_DAYS) {
+          fs.unlinkSync(filePath);
+          deletedCount++;
+          log(`Đã xóa log cũ: ${file}`, "INFO");
+        }
+      }
+    });
+
+    if (deletedCount > 0) {
+      log(`Hoàn thành dọn dẹp log cũ, đã xóa ${deletedCount} file`, "INFO");
+    }
+  } catch (error) {
+    log(`Lỗi khi dọn dẹp log cũ: ${error.message}`, "ERROR");
+  }
+}
+
+/**
+ * Tìm đường dẫn chính xác đến file pm2.cmd trên Windows
+ * @returns {Promise<string|null>} Trả về đường dẫn đến pm2.cmd hoặc null nếu không tìm thấy
+ */
+async function findPM2Command() {
+  const possiblePaths = [];
+
+  // 1. Kiểm tra trong PATH environment
+  const pathEnv = process.env.PATH || "";
+  const pathDirs = pathEnv.split(path.delimiter);
+
+  for (const dir of pathDirs) {
+    if (dir.trim()) {
+      possiblePaths.push(path.join(dir, "pm2.cmd"));
+      possiblePaths.push(path.join(dir, "pm2.exe"));
+    }
+  }
+
+  // 2. Kiểm tra global npm packages
+  const userProfile = os.homedir();
+  possiblePaths.push(path.join(userProfile, "AppData", "Roaming", "npm", "pm2.cmd"));
+  possiblePaths.push(path.join(userProfile, "AppData", "Local", "npm", "pm2.cmd"));
+
+  // 3. Kiểm tra Program Files
+  const programFiles = process.env.ProgramFiles || "C:\\Program Files";
+  const programFilesX86 = process.env["ProgramFiles(x86)"] || "C:\\Program Files (x86)";
+
+  possiblePaths.push(path.join(programFiles, "nodejs", "pm2.cmd"));
+  possiblePaths.push(path.join(programFilesX86, "nodejs", "pm2.cmd"));
+  possiblePaths.push(path.join(programFiles, "npm", "pm2.cmd"));
+  possiblePaths.push(path.join(programFilesX86, "npm", "pm2.cmd"));
+
+  // 4. Kiểm tra trong thư mục hiện tại và node_modules
+  const currentDir = process.cwd();
+  possiblePaths.push(path.join(currentDir, "node_modules", ".bin", "pm2.cmd"));
+  possiblePaths.push(path.join(currentDir, "node_modules", "pm2", "bin", "pm2.cmd"));
+
+  // 5. Kiểm tra theo cấu trúc thư mục phổ biến
+  const commonPaths = ["C:\\npm\\pm2.cmd", "C:\\nodejs\\pm2.cmd", "C:\\tools\\pm2.cmd"];
+  possiblePaths.push(...commonPaths);
+
+  // 6. Tìm kiếm trong thư mục user khác
+  try {
+    const usersDir = "C:\\Users";
+    if (fs.existsSync(usersDir)) {
+      const users = fs.readdirSync(usersDir);
+      for (const user of users) {
+        possiblePaths.push(path.join(usersDir, user, "AppData", "Roaming", "npm", "pm2.cmd"));
+        possiblePaths.push(path.join(usersDir, user, "AppData", "Local", "npm", "pm2.cmd"));
+      }
+    }
+  } catch (e) {
+    // Ignore error khi không có quyền truy cập
+  }
+
+  // Kiểm tra từng đường dẫn
+  for (const pm2Path of possiblePaths) {
+    try {
+      if (fs.existsSync(pm2Path)) {
+        // Kiểm tra file có thể thực thi được không
+        const stats = fs.statSync(pm2Path);
+        if (stats.isFile()) {
+          return pm2Path;
+        }
+      }
+    } catch (e) {
+      // Ignore error và tiếp tục tìm
+      continue;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Lấy danh sách PM2 processes
+ * @returns {Promise<Array>} Danh sách processes hoặc mảng rỗng nếu có lỗi
+ */
+async function getPM2List() {
+  return new Promise(async (resolve) => {
+    // Thử chạy pm2 trực tiếp trước
+    exec("pm2 jlist", async (error, stdout, stderr) => {
+      if (!error && !stderr) {
+        try {
+          const processList = JSON.parse(stdout);
+          return resolve(processList);
+        } catch (parseError) {
+          log(`Lỗi khi parse JSON từ pm2 command: ${parseError.message}`, "ERROR");
+        }
+      }
+
+      // Nếu pm2 command không hoạt động, tìm đường dẫn chính xác
+      log("PM2 command không tìm thấy trong PATH, đang tìm kiếm đường dẫn...", "INFO");
+
+      const pm2Path = await findPM2Command();
+
+      if (!pm2Path) {
+        log("Không tìm thấy PM2 được cài đặt trên hệ thống", "ERROR");
+        return resolve([]);
+      }
+
+      log(`Tìm thấy PM2 tại: ${pm2Path}`, "INFO");
+
+      // Chạy PM2 với đường dẫn đầy đủ
+      exec(`"${pm2Path}" jlist`, (error, stdout, stderr) => {
+        if (error) {
+          log(`Lỗi khi chạy PM2 tại ${pm2Path}: ${error.message}`, "ERROR");
+          return resolve([]);
+        }
+
+        if (stderr) {
+          log(`PM2 stderr: ${stderr}`, "ERROR");
+          return resolve([]);
+        }
+
+        try {
+          const processList = JSON.parse(stdout);
+          resolve(processList);
+        } catch (parseError) {
+          log(`Lỗi khi parse JSON từ ${pm2Path}: ${parseError.message}`, "ERROR");
+          resolve([]);
+        }
+      });
+    });
+  });
+}
+
+async function getPM2List_old() {
+  return new Promise((resolve) => {
+    pm2.connect((err) => {
+      if (err) {
+        log(`Lỗi khi kết nối PM2: ${err.message}`, "ERROR");
+        return resolve([]);
+      }
+
+      pm2.list((err, processList) => {
+        if (err) {
+          log(`Lỗi khi lấy danh sách PM2: ${err.message}`, "ERROR");
+          return resolve([]);
+        }
+
+        pm2.disconnect(); // Đảm bảo ngắt kết nối sau khi lấy danh sách
+        resolve(processList);
+      });
+    });
+  });
+}
+
+// Hàm kiểm tra trạng thái của một service
+function isServiceRunning(processList, serviceName) {
+  const process = processList.find((p) => p.name === serviceName);
+  if (!process) {
+    log(`Không tìm thấy service: ${serviceName}`, "WARNING");
+    return false;
+  }
+
+  const status = process.pm2_env.status;
+  const pid = process.pid;
+  const uptime = process.pm2_env.pm_uptime;
+  const memory = process.monit.memory;
+  const cpu = process.monit.cpu;
+
+  // Log thông tin chi tiết về service
+  log(`Service ${serviceName} - Status: ${status}, PID: ${pid}, Memory: ${(memory / 1024 / 1024).toFixed(2)}MB, CPU: ${cpu}%`, "DEBUG");
+
+  return status === "online";
+}
+
+/**
+ * Khởi động lại PM2 service
+ * @param {string} serviceName - Tên service cần restart
+ * @returns {Promise<boolean>} True nếu thành công, false nếu thất bại
+ */
+async function restartService(serviceName) {
+  try {
+    log(`Đang khởi động lại service: ${serviceName}`, "INFO");
+
+    // Thử chạy pm2 trực tiếp trước
+    try {
+      const { stdout, stderr } = await execAsync(`pm2 restart ${serviceName}`);
+
+      if (stderr) {
+        log(`Cảnh báo khi restart ${serviceName}: ${stderr}`, "WARNING");
+      }
+
+      log(`Đã khởi động lại thành công: ${serviceName}`, "SUCCESS");
+      log(`PM2 Output: ${stdout}`, "DEBUG");
+      return true;
+    } catch (directError) {
+      // Nếu pm2 command không hoạt động, tìm đường dẫn chính xác
+      log("PM2 command không tìm thấy trong PATH, đang tìm kiếm đường dẫn...", "INFO");
+
+      const pm2Path = await findPM2Command();
+
+      if (!pm2Path) {
+        log("Không tìm thấy PM2 được cài đặt trên hệ thống", "ERROR");
+        return false;
+      }
+
+      log(`Tìm thấy PM2 tại: ${pm2Path}, đang restart service...`, "INFO");
+
+      // Chạy PM2 với đường dẫn đầy đủ
+      const { stdout, stderr } = await execAsync(`"${pm2Path}" restart ${serviceName}`);
+
+      if (stderr) {
+        log(`Cảnh báo khi restart ${serviceName}: ${stderr}`, "WARNING");
+      }
+
+      log(`Đã khởi động lại thành công: ${serviceName}`, "SUCCESS");
+      log(`PM2 Output: ${stdout}`, "DEBUG");
+      return true;
+    }
+  } catch (error) {
+    log(`Lỗi khi khởi động lại ${serviceName}: ${error.message}`, "ERROR");
+    return false;
+  }
+}
+
+// Hàm khởi động lại service
+async function restartService_old(serviceName) {
+  try {
+    log(`Đang khởi động lại service: ${serviceName}`, "INFO");
+    const { stdout, stderr } = await execAsync(`pm2 restart ${serviceName}`);
+
+    if (stderr) {
+      log(`Cảnh báo khi restart ${serviceName}: ${stderr}`, "WARNING");
+    }
+
+    log(`Đã khởi động lại thành công: ${serviceName}`, "SUCCESS");
+    log(`PM2 Output: ${stdout}`, "DEBUG");
+    return true;
+  } catch (error) {
+    log(`Lỗi khi khởi động lại ${serviceName}: ${error.message}`, "ERROR");
+    return false;
+  }
+}
+
+// Hàm kiểm tra và khởi động lại các service bị dừng
+async function checkAndRestartServices() {
+  try {
+    log("Bắt đầu kiểm tra trạng thái các service...", "INFO");
+
+    const processList = await getPM2List();
+
+    if (processList.length === 0) {
+      log("Không có process PM2 nào đang chạy", "WARNING");
+      return;
+    }
+
+    let servicesChecked = 0;
+    let servicesRestarted = 0;
+
+    for (const serviceName of SERVICES_TO_MONITOR) {
+      servicesChecked++;
+      const isRunning = isServiceRunning(processList, serviceName);
+
+      if (!isRunning) {
+        log(`Service ${serviceName} đang bị dừng hoặc không tồn tại.`, "WARNING");
+        const serviceExists = processList.some((p) => p.name === serviceName);
+
+        if (!serviceExists) {
+          log(`Service ${serviceName} không tồn tại, chạy pm2.js...`, "INFO");
+          try {
+            let pm2JSPath = path.join(path.dirname(__filename), "pm2.js");
+            log(`__filename:${__filename}`);
+            log(`pm2JSPath:${pm2JSPath}`);
+            log(`process.cwd():${process.cwd()}`);
+            const { stdout, stderr } = await execAsync(`node ${pm2JSPath}`, { cwd: process.cwd() });
+            if (stderr) {
+              log(`Lỗi khi chạy pm2.js: ${stderr}`, "ERROR");
+            }
+            log(`pm2.js đã được chạy. Output: ${stdout}`, "INFO");
+          } catch (error) {
+            log(`Lỗi khi chạy pm2.js: ${error.message}`, "ERROR");
+          }
+        } else {
+          log(`Service ${serviceName} đang bị dừng, tiến hành khởi động lại...`, "WARNING");
+          const restartSuccess = await restartService(serviceName);
+
+          if (restartSuccess) {
+            servicesRestarted++;
+          }
+
+          // Chờ một chút trước khi kiểm tra service tiếp theo
+          await new Promise((resolve) => setTimeout(resolve, 2000));
+        }
+      } else {
+        log(`Service ${serviceName} đang hoạt động bình thường`, "INFO");
+      }
+    }
+
+    log(`Hoàn thành kiểm tra ${servicesChecked} service(s), đã restart ${servicesRestarted} service(s)`, "INFO");
+  } catch (error) {
+    log(`Lỗi trong quá trình kiểm tra: ${error.message}`, "ERROR");
+  }
+}
+
+// Hàm chính để chạy monitor
+async function startMonitoring() {
+  // Khởi tạo thư mục log
+  ensureLogDirectory();
+
+  log("=== BẮT ĐẦU GIÁM SÁT CÁC SERVICE PM2 ===", "INFO");
+  log(`Các service được giám sát: ${SERVICES_TO_MONITOR.join(", ")}`, "INFO");
+  log(`Thời gian kiểm tra: ${CHECK_INTERVAL / 1000} giây`, "INFO");
+  log(`Thư mục log: ${LOG_DIR}`, "INFO");
+  log(`Thời gian giữ log: ${LOG_RETENTION_DAYS} ngày`, "INFO");
+
+  // Dọn dẹp log cũ ngay khi khởi động
+  cleanupOldLogs();
+
+  // Kiểm tra ngay lập tức
+  await checkAndRestartServices();
+
+  // Thiết lập interval để kiểm tra định kỳ
+  setInterval(async () => {
+    await checkAndRestartServices();
+  }, CHECK_INTERVAL);
+
+  // Thiết lập interval để dọn dẹp log cũ
+  setInterval(() => {
+    cleanupOldLogs();
+  }, LOG_CLEANUP_INTERVAL);
+}
+
+// Xử lý khi nhận signal để thoát gracefully
+process.on("SIGINT", () => {
+  log("Nhận signal SIGINT, đang thoát chương trình...", "INFO");
+  process.exit(0);
+});
+
+process.on("SIGTERM", () => {
+  log("Nhận signal SIGTERM, đang thoát chương trình...", "INFO");
+  process.exit(0);
+});
+
+// Xử lý lỗi không được catch
+process.on("unhandledRejection", (reason, promise) => {
+  log(`Unhandled Rejection at: ${promise}, reason: ${reason}`, "ERROR");
+});
+
+process.on("uncaughtException", (error) => {
+  log(`Uncaught Exception: ${error.message}`, "ERROR");
+  log(`Stack: ${error.stack}`, "ERROR");
+  process.exit(1);
+});
+
+// Bắt đầu monitoring
+if (require.main === module) {
+  startMonitoring().catch((error) => {
+    log(`Lỗi khi khởi động monitor: ${error.message}`, "ERROR");
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  startMonitoring,
+  checkAndRestartServices,
+  cleanupOldLogs,
+  SERVICES_TO_MONITOR,
+  LOG_RETENTION_DAYS,
+  LOG_DIR,
+};