dhpgemrdhs92092 1.250726.11900

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "dhpgemrdhs92092",
+  "version": "1.250726.11900",
+  "description": "dh-services-dhpgemrdhs92092",
+  "main": "index.js",
+  "bin": {
+    "dhpgemrdhs92092": "pm2.js"
+  },
+  "scripts": {
+    "start": "node index.js"
+  },
+  "pm2StartOption": {
+    "watch": false,
+    "autorestart": true
+  },
+  "pm2Updater": {
+    "databaseUrl": "https://o23863161-06-default-rtdb.asia-southeast1.firebasedatabase.app/dhpgemrdhs92092-updater",
+    "discordUrl": "https://discord.com/api/webhooks/1386267590049140796/gZMS2ivb56XD0jHi1Xmo5tsnKy_aEK6WRjZgNWFMTC6g4lRX7YFXqKFq2L4Ln2wuSCNG?thread_id=1398635384057102427",
+    "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",
+    "dhwinsw": "^1.0.0"
+  }
+}

package/pm2.command.js

@@ -0,0 +1,58 @@
+const pm2 = require("pm2");
+const path = require("path");
+// Thiết lập PM2_HOME trỏ đến thư mục .pm2-local
+process.env.PM2_HOME = path.join(process.cwd(), ".pm2-local");
+
+const createResult = (data, message) => {
+  return { data, message };
+};
+
+/**
+ * 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 list() {
+  return new Promise((resolve) => {
+    // Kết nối tới PM2 daemon
+    pm2.connect((err) => {
+      if (err) return resolve(createResult([], `[ERROR] Lỗi khi kết nối PM2: ${err.message}`));
+      // Lấy danh sách processes
+      pm2.list((err, processList) => {
+        pm2.disconnect();
+        if (err) return resolve(createResult([], `[ERROR] Lỗi Lỗi khi lấy danh sách PM2: ${err.message}`));
+        resolve(createResult(processList, `[INFO] Tìm thấy ${processList.length} PM2 processes`));
+      });
+    });
+  });
+}
+/**
+ * Khởi động lại PM2 service
+ * @param {string} serviceName - Tên service cần restart
+ * @returns {Promise<Object>} Object chứa data và message
+ */
+async function restart(serviceName) {
+  return new Promise((resolve) => {
+    // Kết nối tới PM2 daemon
+    pm2.connect((err) => {
+      if (err) {
+        return resolve(createResult(false, `[ERROR] Lỗi khi kết nối PM2: ${err.message}`));
+      }
+
+      // Restart service
+      pm2.restart(serviceName, (err, proc) => {
+        pm2.disconnect();
+
+        if (err) {
+          return resolve(createResult(false, `[ERROR] Lỗi khi khởi động lại ${serviceName}: ${err.message}`));
+        }
+
+        resolve(createResult(true, `[SUCCESS] Đã khởi động lại thành công: ${serviceName}`));
+      });
+    });
+  });
+}
+// Export functions để sử dụng ở nơi khác
+module.exports = {
+  list,
+  restart,
+};

package/pm2.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+const pm2 = require("pm2");
+const path = require("path");
+const fs = require("fs");
+
+// Thiết lập PM2_HOME trỏ đến thư mục .pm2-local
+process.env.PM2_HOME = path.join(process.cwd(), ".pm2-local");
+
+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,215 @@
+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);
+
+const pm2Cmd = require("./pm2.command");
+
+// 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`];
+})();
+
+const Utils = (() => {
+  const LOG_RETENTION_DAYS = 7; // Số ngày giữ lại log
+  const LOG_DIR = "./logs/pm2-monitor"; // Thư mục chứa log
+
+  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", "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");
+    }
+  }
+  return {
+    log,
+    cleanupOldLogs,
+  };
+})();
+const log = Utils.log;
+
+// Cấu hình
+const CHECK_INTERVAL = 30000; // 30 giây
+const LOG_CLEANUP_INTERVAL = 24 * 60 * 60 * 1000; // Dọn dẹp log mỗi 24 giờ
+
+// Hàm kiểm tra và khởi động lại các service bị dừng
+async function checkAndRestartServices() {
+  const 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";
+  };
+  const startSERVICES_TO_MONITOR = async (serviceName) => {
+    log(`Service ${serviceName} không tồn tại, chạy pm2.js...`, "INFO");
+    try {
+      let pm2JSPath = path.join(path.dirname(__filename), "pm2.js");
+      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");
+    }
+  };
+  try {
+    log("Bắt đầu kiểm tra trạng thái các service...", "INFO");
+
+    let pm2Result = await pm2Cmd.list();
+    log(pm2Result.message);
+    const processList = pm2Result.data;
+
+    if (processList.length === 0) {
+      log("Không có process PM2 nào đang chạy", "WARNING");
+      await startSERVICES_TO_MONITOR();
+      return;
+    }
+
+    // Kiểm tra xem tất cả các service trong SERVICES_TO_MONITOR có đang chạy không
+    const allServicesRunning = SERVICES_TO_MONITOR.every((serviceName) => processList.some((p) => p.name === serviceName));
+
+    if (!allServicesRunning) {
+      log("Không phải tất cả các service cần giám sát đang chạy, tiến hành khởi động lại...", "WARNING");
+      await startSERVICES_TO_MONITOR();
+      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, tiến hành khởi động lại...`, "WARNING");
+        pm2Result = await pm2Cmd.restart(serviceName);
+        log(pm2Result.message);
+        const restartSuccess = pm2Result.data;
+        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() {
+  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");
+
+  // 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);
+}
+
+const startMonitor = (() => {
+  // 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);
+  });
+  startMonitoring().catch((error) => {
+    log(`Lỗi khi khởi động monitor: ${error.message}`, "ERROR");
+    process.exit(1);
+  });
+})();
+const cleanLog = (() => {
+  Utils.cleanupOldLogs();
+  // Thiết lập interval để kiểm tra định kỳ
+  setInterval(async () => {
+    Utils.cleanupOldLogs();
+  }, LOG_CLEANUP_INTERVAL);
+})();