dhpgemrdhs92092 1.250728.11937 → 1.250815.12029

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dhpgemrdhs92092",
-  "version": "1.250728.11937",
+  "version": "1.250815.12029",
   "description": "dh-services-dhpgemrdhs92092",
   "main": "index.js",
   "bin": {

package/pm2.command.js

@@ -1,5 +1,6 @@
 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");
 
@@ -13,15 +14,66 @@ const createResult = (data, message) => {
  */
 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`));
+    // Nghiệp vụ 1: Lấy danh sách PM2 qua CLI
+    const listByCLI = () => {
+      return new Promise((resolveCLI) => {
+        const { exec } = require("child_process");
+
+        exec(
+          "npx pm2 jlist",
+          {
+            cwd: process.cwd(),
+            timeout: 10000, // timeout 10s
+          },
+          (error, stdout, stderr) => {
+            // Nếu npx pm2 thành công và có kết quả
+            if (!error && stdout && stdout.trim()) {
+              try {
+                const processList = JSON.parse(stdout.trim());
+                if (Array.isArray(processList)) {
+                  return resolveCLI({ success: true, data: processList });
+                }
+              } catch (parseErr) {
+                return resolveCLI({ success: false, error: `JSON parse error: ${parseErr.message}` });
+              }
+            }
+
+            resolveCLI({ success: false, error: error ? error.message : "No output from npx pm2" });
+          }
+        );
       });
+    };
+
+    // Nghiệp vụ 2: Lấy danh sách PM2 qua Package PM2
+    const listByPackagePm2 = () => {
+      return new Promise((resolvePackage) => {
+        pm2.connect((err) => {
+          if (err) return resolvePackage({ success: false, 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 resolvePackage({ success: false, error: `Lỗi khi lấy danh sách PM2: ${err.message}` });
+            resolvePackage({ success: true, data: processList });
+          });
+        });
+      });
+    };
+
+    // Thực thi: Thử CLI trước, nếu thất bại thì dùng Package PM2
+    listByCLI().then((cliResult) => {
+      if (cliResult.success) {
+        resolve(createResult(cliResult.data, `[INFO] Tìm thấy ${cliResult.data.length} PM2 processes (via CLI)`));
+      } else {
+        // Fallback sang Package PM2
+        listByPackagePm2().then((packageResult) => {
+          if (packageResult.success) {
+            resolve(createResult(packageResult.data, `[INFO] Tìm thấy ${packageResult.data.length} PM2 processes (via Package)`));
+          } else {
+            resolve(createResult([], `[ERROR] ${packageResult.error}`));
+          }
+        });
+      }
     });
   });
 }
@@ -31,28 +83,219 @@ async function list() {
  * @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}`));
+  const { exec } = require("child_process");
+  const util = require("util");
+  const execAsync = util.promisify(exec);
+  console.info(`[INFO] Starting restart process for ${serviceName}`);
+
+  // ==================== LOGIC 1: CLI METHOD ====================
+  async function tryRestartByCLI() {
+    try {
+      console.info(`[INFO] Attempting CLI restart for ${serviceName}...`);
+      // Thực hiện restart bằng CLI
+      const { stdout, stderr } = await execAsync(`npx pm2 restart ${serviceName}`, {
+        timeout: 30000, // 30 giây timeout
+        cwd: process.cwd(),
+      });
+      // Kiểm tra error trong stderr
+      if (stderr && stderr.includes("ERROR")) {
+        throw new Error(stderr);
+      }
+      console.info(`[INFO] CLI restart output: ${stdout}`);
+      return createResult(true, `[SUCCESS] Đã khởi động lại thành công bằng CLI: ${serviceName}`);
+    } catch (error) {
+      console.error(`[ERROR] CLI restart failed: ${error.message}`);
+      return createResult(false, `CLI method failed: ${error.message}`);
+    }
+  }
+
+  // ==================== LOGIC 2: PACKAGE METHOD ====================
+  async function tryRestartByPackage() {
+    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}`));
+        });
+      });
+    });
+  }
+
+  // ==================== MAIN EXECUTION FLOW ====================
+  try {
+    // BƯỚC 1: Thử CLI method trước
+    console.info("[INFO] Step 1: Trying CLI method...");
+    const cliResult = await tryRestartByCLI();
+
+    if (cliResult.data === true) {
+      console.info("[INFO] CLI method succeeded, returning result");
+      return cliResult;
+    }
+
+    // BƯỚC 2: Nếu CLI fail, thử package method
+    console.warn("[WARNING] CLI method failed, trying package method...");
+    console.info("[INFO] Step 2: Trying package method...");
+    const packageResult = await tryRestartByPackage();
+
+    if (cliResult.data === true) {
+      console.info("[INFO] Package method succeeded, returning result");
+      return packageResult;
+    }
+
+    // BƯỚC 3: Cả hai đều fail
+    console.error("[ERROR] Both CLI and package methods failed");
+    return createResult(false, `[ERROR] Cả hai phương thức đều thất bại. CLI: ${cliResult.message}. Package: ${packageResult.message}`);
+  } catch (error) {
+    console.error(`[ERROR] Unexpected error in main flow: ${error.message}`);
+    return createResult(false, `[ERROR] Lỗi không mong muốn: ${error.message}`);
+  }
+}
+/**
+ * Stop PM2 service
+ * @param {string} serviceName - Tên service cần stop
+ * @returns {Promise<Object>} Object chứa data và message
+ */
+async function stop(serviceName) {
+  const { exec } = require("child_process");
+  const util = require("util");
+  const pm2 = require("pm2"); // Thêm import pm2
+  const execAsync = util.promisify(exec);
+
+  console.info(`[INFO] Starting stop process for ${serviceName}`);
+
+  // ==================== LOGIC 1: CLI METHOD ====================
+  async function tryStopByCLI() {
+    try {
+      console.info(`[INFO] Attempting CLI stop for ${serviceName}...`);
+
+      // Thực hiện stop bằng CLI
+      const { stdout, stderr } = await execAsync(`npx pm2 stop ${serviceName}`, {
+        timeout: 30000, // 30 giây timeout
+        cwd: process.cwd(),
+      });
+
+      console.info(`[INFO] CLI stop output: ${stdout}`);
+      console.info(`[INFO] CLI stop stderr: ${stderr}`);
+
+      // Kiểm tra các trường hợp đặc biệt
+      if (
+        stdout.includes("doesn't exist") ||
+        stdout.includes("not found") ||
+        (stderr.includes("Process or Namespace") && stderr.includes("not found"))
+      ) {
+        return createResult(true, `[INFO] Service ${serviceName} không tồn tại - coi như đã stop thành công`);
+      }
+
+      if (stdout.includes("already stopped") || stdout.includes("stopped")) {
+        return createResult(true, `[INFO] Service ${serviceName} đã được stop thành công hoặc đã stop từ trước`);
+      }
+
+      // Kiểm tra error thực sự trong stderr (loại trừ warning)
+      if (stderr && stderr.includes("ERROR") && !stderr.includes("doesn't exist")) {
+        throw new Error(stderr);
+      }
+
+      return createResult(true, `[SUCCESS] Đã stop thành công bằng CLI: ${serviceName}`);
+    } catch (error) {
+      console.error(`[ERROR] CLI stop failed: ${error.message}`);
+
+      // Kiểm tra nếu lỗi là do service không tồn tại
+      if (
+        error.message.includes("doesn't exist") ||
+        error.message.includes("not found") ||
+        error.message.includes("Process or Namespace") ||
+        error.message.includes("not found")
+      ) {
+        return createResult(true, `[INFO] Service ${serviceName} không tồn tại - coi như đã stop thành công`);
       }
 
-      // Restart service
-      pm2.restart(serviceName, (err, proc) => {
-        pm2.disconnect();
+      return createResult(false, `CLI method failed: ${error.message}`);
+    }
+  }
 
+  // ==================== LOGIC 2: PACKAGE METHOD ====================
+  async function tryStopByPackage() {
+    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 khởi động lại ${serviceName}: ${err.message}`));
+          return resolve(createResult(false, `[ERROR] Lỗi khi kết nối PM2: ${err.message}`));
         }
 
-        resolve(createResult(true, `[SUCCESS] Đã khởi động lại thành công: ${serviceName}`));
+        // Stop service
+        pm2.stop(serviceName, (err, proc) => {
+          pm2.disconnect();
+
+          if (err) {
+            console.error(`[ERROR] Package stop error: ${err.message}`);
+
+            // Kiểm tra các trường hợp đặc biệt
+            if (err.message.includes("doesn't exist") || err.message.includes("not found") || err.message.includes("Process or Namespace")) {
+              return resolve(createResult(true, `[INFO] Service ${serviceName} không tồn tại - coi như đã stop thành công`));
+            }
+
+            if (err.message.includes("already stopped")) {
+              return resolve(createResult(true, `[INFO] Service ${serviceName} đã được stop từ trước`));
+            }
+
+            return resolve(createResult(false, `[ERROR] Lỗi khi stop ${serviceName}: ${err.message}`));
+          }
+
+          // Kiểm tra kết quả proc
+          if (proc && proc.length === 0) {
+            return resolve(createResult(true, `[INFO] Service ${serviceName} không tồn tại hoặc đã được xử lý`));
+          }
+
+          resolve(createResult(true, `[SUCCESS] Đã stop thành công: ${serviceName}`));
+        });
       });
     });
-  });
+  }
+
+  // ==================== MAIN EXECUTION FLOW ====================
+  try {
+    // BƯỚC 1: Thử CLI method trước
+    console.info("[INFO] Step 1: Trying CLI method...");
+    const cliResult = await tryStopByCLI();
+
+    if (cliResult.data === true) {
+      console.info("[INFO] CLI method succeeded, returning result");
+      return cliResult;
+    }
+
+    // BƯỚC 2: Nếu CLI fail, thử package method
+    console.warn("[WARNING] CLI method failed, trying package method...");
+    console.info("[INFO] Step 2: Trying package method...");
+    const packageResult = await tryStopByPackage();
+
+    if (packageResult.data === true) {
+      // FIX: Đã sửa từ cliResult thành packageResult
+      console.info("[INFO] Package method succeeded, returning result");
+      return packageResult;
+    }
+
+    // BƯỚC 3: Cả hai đều fail
+    console.error("[ERROR] Both CLI and package methods failed");
+    return createResult(false, `[ERROR] Cả hai phương thức đều thất bại. CLI: ${cliResult.message}. Package: ${packageResult.message}`);
+  } catch (error) {
+    console.error(`[ERROR] Unexpected error in main flow: ${error.message}`);
+    return createResult(false, `[ERROR] Lỗi không mong muốn: ${error.message}`);
+  }
 }
+
 // Export functions để sử dụng ở nơi khác
 module.exports = {
   list,
   restart,
+  stop,
 };

package/pm2.monitor.js

@@ -8,6 +8,8 @@ const os = require("os");
 const execAsync = util.promisify(exec);
 
 const pm2Cmd = require("./pm2.command");
+// Thiết lập PM2_HOME trỏ đến thư mục .pm2-local
+process.env.PM2_HOME = path.join(process.cwd(), ".pm2-local");
 
 // Danh sách các dịch vụ cần giám sát
 const SERVICES_TO_MONITOR = (() => {
@@ -86,7 +88,7 @@ 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() {
+async function checkAndRestartServices(isRunByStartupMonitor = false) {
   const isServiceRunning = (processList, serviceName) => {
     const process = processList.find((p) => p.name === serviceName);
     if (!process) {
@@ -147,8 +149,10 @@ async function checkAndRestartServices() {
       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");
+      if (isRunByStartupMonitor === true || !isRunning) {
+        let mess = `Service ${serviceName} đang bị dừng, tiến hành khởi động lại...`;
+        if (isRunByStartupMonitor === true) mess = `Service ${serviceName} khởi động lại by isRunByStartupMonitor===true...`;
+        log(mess, "WARNING");
         pm2Result = await pm2Cmd.restart(serviceName);
         log(pm2Result.message);
         const restartSuccess = pm2Result.data;
@@ -167,6 +171,22 @@ async function checkAndRestartServices() {
   }
 }
 
+async function stopServices() {
+  try {
+    for (const serviceName of SERVICES_TO_MONITOR) {
+      try {
+        let pm2Result = await pm2Cmd.stop(serviceName);
+        log(pm2Result.message);
+        // Chờ một chút trước khi kiểm tra service tiếp theo
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+      } catch (error) {
+        log(`Lỗi trong quá trình stopServices ${serviceName}: ${error.message}`, "ERROR");
+      }
+    }
+  } catch (error) {
+    log(`Lỗi trong quá trình stopServices: ${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");
@@ -174,24 +194,33 @@ async function startMonitoring() {
   log(`Thời gian kiểm tra: ${CHECK_INTERVAL / 1000} giây`, "INFO");
 
   // Kiểm tra ngay lập tức
-  await checkAndRestartServices();
+  await checkAndRestartServices(true);
 
   // Thiết lập interval để kiểm tra định kỳ
   setInterval(async () => {
-    await checkAndRestartServices();
+    await checkAndRestartServices(false);
   }, 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");
+  let isExiting = false;
+  async function gracefulShutdown(signal) {
+    if (isExiting) return;
+    isExiting = true;
+
+    log(`Nhận signal ${signal}, đang dừng các services...`, "INFO");
+
+    try {
+      await stopServices();
+      log("Đã dừng xong các services, thoát chương trình...", "INFO");
+    } catch (error) {
+      log(`Lỗi khi dừng services: ${error.message}`, "ERROR");
+    }
+
     process.exit(0);
-  });
+  }
+  process.on("SIGINT", () => gracefulShutdown("SIGINT"));
+  process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
   // Xử lý lỗi không được catch
   process.on("unhandledRejection", (reason, promise) => {
     log(`Unhandled Rejection at: ${promise}, reason: ${reason}`, "ERROR");
@@ -199,7 +228,7 @@ const startMonitor = (() => {
   process.on("uncaughtException", (error) => {
     log(`Uncaught Exception: ${error.message}`, "ERROR");
     log(`Stack: ${error.stack}`, "ERROR");
-    process.exit(1);
+    // process.exit(1);
   });
   startMonitoring().catch((error) => {
     log(`Lỗi khi khởi động monitor: ${error.message}`, "ERROR");