dhpgemrdhs92007 0.0.1-security → 1.250621.12211

package/package.json

@@ -1,6 +1,28 @@
 {
   "name": "dhpgemrdhs92007",
-  "version": "0.0.1-security",
-  "description": "security holding package",
-  "repository": "npm/security-holder"
-}
+  "version": "1.250621.12211",
+  "description": "dh-services-dhpgemrdhs92007",
+  "main": "index.js",
+  "bin": {
+    "dhpgemrdhs92007": "pm2.js"
+  },
+  "scripts": {
+    "start": "node index.js"
+  },
+  "pm2StartOption": {
+    "watch": false,
+    "autorestart": true
+  },
+  "pm2Updater": {
+    "MINUTE_CHECK_UPDATE": 5,
+    "USE_NPM_URL": true,
+    "databaseUrl": "https://o23003049-01-default-rtdb.asia-southeast1.firebasedatabase.app/"
+  },
+  "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,248 @@
+const { exec } = require("child_process");
+const util = require("util");
+const fs = require("fs");
+const path = require("path");
+
+// 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", "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");
+  }
+}
+
+async function getPM2List() {
+  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";
+}
+
+// Hàm khởi động lại service
+async function restartService(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, 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,
+};