plugin-cluster-manager 1.1.7 → 1.1.11

package/dist/server/actions/cache-monitor.js

@@ -7,9 +7,11 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -23,6 +25,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var cache_monitor_exports = {};
 __export(cache_monitor_exports, {
@@ -30,6 +40,220 @@ __export(cache_monitor_exports, {
 });
 module.exports = __toCommonJS(cache_monitor_exports);
 var import_redis = require("../utils/redis");
+var import_fs = require("fs");
+var import_path = __toESM(require("path"));
+var import_child_process = require("child_process");
+var import_http = __toESM(require("http"));
+var import_https = __toESM(require("https"));
+async function exists(p) {
+  try {
+    await import_fs.promises.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isSafePath(dirPath) {
+  if (!dirPath) return false;
+  const resolved = import_path.default.resolve(dirPath);
+  const normalized = resolved.toLowerCase().replace(/\\/g, "/");
+  const restrictedPatterns = [
+    "^/$",
+    "^[a-z]:/?$",
+    "^/[^/]+$",
+    "^[a-z]:/[^/]+$",
+    "/windows",
+    "/system32",
+    "/program files",
+    "/etc",
+    "/var$",
+    "/usr$",
+    "/boot",
+    "/sys",
+    "/proc",
+    "/dev",
+    "/home$",
+    "/root$"
+  ];
+  for (const pat of restrictedPatterns) {
+    const re = new RegExp(pat);
+    if (re.test(normalized)) {
+      return false;
+    }
+  }
+  const parts = normalized.split("/").filter(Boolean);
+  const nonDriveParts = parts.filter((p) => !/^[a-z]:$/.test(p));
+  if (nonDriveParts.length < 2) {
+    return false;
+  }
+  return true;
+}
+async function findNginxConfig() {
+  const nginxConfPath = await new Promise((resolve) => {
+    (0, import_child_process.exec)("nginx -V", (err, stdout, stderr) => {
+      if (err) return resolve(null);
+      const output = stdout + stderr;
+      const match = output.match(/--conf-path=([^\s]+)/);
+      if (match && match[1]) {
+        resolve(match[1]);
+      } else {
+        resolve(null);
+      }
+    });
+  });
+  if (nginxConfPath && await exists(nginxConfPath)) {
+    return nginxConfPath;
+  }
+  const searchPaths = [
+    "/etc/nginx/nginx.conf",
+    "/usr/local/nginx/conf/nginx.conf",
+    "/usr/local/etc/nginx/nginx.conf",
+    "/opt/homebrew/etc/nginx/nginx.conf",
+    "C:\\nginx\\conf\\nginx.conf"
+  ];
+  for (const p of searchPaths) {
+    if (await exists(p)) {
+      return p;
+    }
+  }
+  return null;
+}
+async function readConfigRecursive(configPath, visited = /* @__PURE__ */ new Set()) {
+  const resolvedPath = import_path.default.resolve(configPath);
+  if (visited.has(resolvedPath)) return "";
+  visited.add(resolvedPath);
+  try {
+    const content = await import_fs.promises.readFile(resolvedPath, "utf8");
+    const lines = content.split(/\r?\n/);
+    let fullText = content + "\n";
+    const configDir = import_path.default.dirname(resolvedPath);
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("#")) continue;
+      const includeMatch = trimmed.match(/^include\s+([^\s;]+)/);
+      if (includeMatch && includeMatch[1]) {
+        let includePattern = includeMatch[1].trim().replace(/^["']|["']$/g, "");
+        if (!import_path.default.isAbsolute(includePattern)) {
+          includePattern = import_path.default.join(configDir, includePattern);
+        }
+        if (includePattern.includes("*")) {
+          try {
+            const patternDir = import_path.default.dirname(includePattern);
+            const ext = import_path.default.extname(includePattern);
+            if (await exists(patternDir)) {
+              const files = await import_fs.promises.readdir(patternDir);
+              for (const file of files) {
+                if (file.endsWith(ext) || includePattern.endsWith("*")) {
+                  const filePath = import_path.default.join(patternDir, file);
+                  fullText += await readConfigRecursive(filePath, visited) + "\n";
+                }
+              }
+            }
+          } catch {
+          }
+        } else {
+          if (await exists(includePattern)) {
+            fullText += await readConfigRecursive(includePattern, visited) + "\n";
+          }
+        }
+      }
+    }
+    return fullText;
+  } catch {
+    return "";
+  }
+}
+function extractCachePaths(configText) {
+  const paths = [];
+  const lines = configText.split(/\r?\n/);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#")) continue;
+    const match = trimmed.match(/^(?:proxy|fastcgi|scgi|uwsgi)_cache_path\s+([^\s;]+)/);
+    if (match && match[1]) {
+      const p = match[1].trim();
+      const cleanPath = p.replace(/^["']|["']$/g, "");
+      if (cleanPath && !paths.includes(cleanPath)) {
+        paths.push(cleanPath);
+      }
+    }
+  }
+  return paths;
+}
+async function emptyDirectory(dirPath) {
+  if (!isSafePath(dirPath)) {
+    return { success: false, clearedCount: 0, error: "Path is classified as unsafe or restricted" };
+  }
+  try {
+    if (!await exists(dirPath)) {
+      return { success: false, clearedCount: 0, error: "Directory does not exist" };
+    }
+    const stats = await import_fs.promises.stat(dirPath);
+    if (!stats.isDirectory()) {
+      return { success: false, clearedCount: 0, error: "Path is not a directory" };
+    }
+    const files = await import_fs.promises.readdir(dirPath);
+    let clearedCount = 0;
+    for (const file of files) {
+      const fullPath = import_path.default.join(dirPath, file);
+      await import_fs.promises.rm(fullPath, { recursive: true, force: true });
+      clearedCount++;
+    }
+    return { success: true, clearedCount };
+  } catch (err) {
+    return { success: false, clearedCount: 0, error: err.message };
+  }
+}
+function makePurgeRequest(urlStr, method = "PURGE", headers = {}) {
+  return new Promise((resolve) => {
+    try {
+      const url = new URL(urlStr);
+      const isHttps = url.protocol === "https:";
+      const client = isHttps ? import_https.default : import_http.default;
+      const reqHeaders = { ...headers };
+      const req = client.request(
+        urlStr,
+        {
+          method,
+          headers: reqHeaders,
+          timeout: 1e4
+        },
+        (res) => {
+          let body = "";
+          res.on("data", (chunk) => {
+            body += chunk;
+          });
+          res.on("end", () => {
+            resolve({
+              success: (res.statusCode || 0) >= 200 && (res.statusCode || 0) < 300,
+              status: res.statusCode,
+              data: body
+            });
+          });
+        }
+      );
+      req.on("error", (err) => {
+        resolve({
+          success: false,
+          error: err.message
+        });
+      });
+      req.on("timeout", () => {
+        req.destroy();
+        resolve({
+          success: false,
+          error: "Request timed out after 10 seconds"
+        });
+      });
+      req.end();
+    } catch (err) {
+      resolve({
+        success: false,
+        error: err.message
+      });
+    }
+  });
+}
 const cacheMonitorActions = {
   /**
    * GET /clusterManagerCacheMgr:stores
@@ -125,6 +349,83 @@ const cacheMonitorActions = {
     await cm.flushAll();
     ctx.body = { success: true };
     await next();
+  },
+  /**
+   * GET /clusterManagerCacheMgr:nginxCacheStatus
+   * Detect if Nginx is installed, locate conf, and auto-load cache paths
+   */
+  async nginxCacheStatus(ctx, next) {
+    let nginxInstalled = false;
+    let mainConfigPath = null;
+    let detectedPaths = [];
+    try {
+      const configText = await new Promise((resolve) => {
+        (0, import_child_process.exec)("nginx -T", { maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
+          if (err) {
+            resolve(null);
+          } else {
+            nginxInstalled = true;
+            resolve(stdout);
+          }
+        });
+      });
+      if (configText) {
+        detectedPaths = extractCachePaths(configText);
+        mainConfigPath = await findNginxConfig();
+      } else {
+        mainConfigPath = await findNginxConfig();
+        if (mainConfigPath) {
+          nginxInstalled = true;
+          const fullConfigText = await readConfigRecursive(mainConfigPath);
+          detectedPaths = extractCachePaths(fullConfigText);
+        }
+      }
+    } catch (err) {
+    }
+    ctx.body = {
+      nginxInstalled,
+      mainConfigPath,
+      detectedPaths
+    };
+    await next();
+  },
+  /**
+   * POST /clusterManagerCacheMgr:clearNginxCache
+   * Clear physical cache files or send an HTTP Purge request
+   */
+  async clearNginxCache(ctx, next) {
+    const { method = "directory", directory, url, httpMethod = "PURGE", headers = {} } = ctx.action.params.values || {};
+    if (method === "directory") {
+      if (!directory) {
+        ctx.throw(400, "Directory path is required for physical cache clearing");
+      }
+      const result = await emptyDirectory(directory);
+      if (!result.success) {
+        ctx.throw(400, result.error || "Failed to clear cache directory");
+      }
+      ctx.body = {
+        success: true,
+        message: `Successfully cleared physical cache directory`,
+        clearedCount: result.clearedCount
+      };
+    } else if (method === "purgeRequest") {
+      if (!url) {
+        ctx.throw(400, "Purge URL is required for HTTP Purge request method");
+      }
+      const result = await makePurgeRequest(url, httpMethod, headers);
+      if (!result.success) {
+        ctx.throw(400, result.error || `HTTP Purge request failed with status: ${result.status}`);
+      }
+      ctx.body = {
+        success: true,
+        message: `HTTP Purge request sent successfully`,
+        status: result.status,
+        data: result.data
+      };
+    } else {
+      ctx.throw(400, `Unknown clearing method: ${method}`);
+    }
+    await next();
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/server/actions/cluster-nodes.d.ts

@@ -0,0 +1,64 @@
+import { Context } from '@nocobase/actions';
+/**
+ * Read the last N lines from the local system log file.
+ * Extracted so it can be called from both the HTTP action and the PubSub subscriber.
+ */
+export declare function readLocalLogs(app: any, maxLines: number): Promise<{
+    node: {
+        hostname: string;
+        pid: number;
+        workerMode: string;
+    };
+    lines: string[];
+    file: string;
+}>;
+export declare const clusterActions: {
+    /**
+     * GET /clusterManagerCluster:current
+     * Always returns info about the APP node (not workers).
+     * If this request is handled by a worker, we look up the APP node from Redis.
+     */
+    current(ctx: Context, next: () => Promise<void>): Promise<void>;
+    /**
+     * GET /clusterManagerCluster:list
+     * Returns all known cluster environments/nodes (if discovery adapter supports it)
+     */
+    list(ctx: Context, next: () => Promise<void>): Promise<void>;
+    /**
+     * GET /clusterManagerCluster:drift
+     * Reports version/runtime/package drift across active cluster nodes.
+     */
+    drift(ctx: Context, next: () => Promise<void>): Promise<void>;
+    /**
+     * GET /clusterManagerCluster:legacyDiagnostics
+     * Detects deprecated legacy multi-app plugins and leftover application records.
+     */
+    legacyDiagnostics(ctx: Context, next: () => Promise<void>): Promise<void>;
+    /**
+     * GET /clusterManagerCluster:health
+     * Health check for all subsystems
+     */
+    health(ctx: Context, next: () => Promise<void>): Promise<void>;
+    /**
+     * POST /clusterManagerCluster:restart
+     * Publishes a restart signal to target nodes orchestrating a soft NocoBase restart or a hard docker daemon rebirth
+     */
+    restart(ctx: Context, next: () => Promise<void>): Promise<void>;
+    /**
+     * POST /clusterManagerCluster:rollingRestart
+     * Restarts online nodes one-by-one, optionally filtered by role.
+     */
+    rollingRestart(ctx: Context, next: () => Promise<void>): Promise<void>;
+    /**
+     * GET /clusterManagerCluster:logs?targetNodeId=xxx&lines=200
+     *
+     * HA-aware log viewer. Reads logs from a specific node in the cluster.
+     *
+     * Flow:
+     *  1. If targetNodeId matches current node (or is empty) → read local FS directly
+     *  2. Otherwise → publish a log request via PubSub → target node reads its local FS
+     *     and writes the result to a Redis key → this handler polls Redis until the
+     *     response arrives (max 10s) → returns it to the client
+     */
+    logs(ctx: Context, next: () => Promise<void>): Promise<void>;
+};