plugin-cluster-manager 1.0.12

package/dist/server/utils/redis.js

@@ -0,0 +1,94 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var redis_exports = {};
+__export(redis_exports, {
+  deleteKeysChunked: () => deleteKeysChunked,
+  getRedis: () => getRedis,
+  getRedisClient: () => getRedisClient,
+  getRedisOrThrow: () => getRedisOrThrow,
+  scanKeys: () => scanKeys
+});
+module.exports = __toCommonJS(redis_exports);
+var import_redis = require("redis");
+let globalRedisClient = null;
+function getRedisClient(app) {
+  if (globalRedisClient) return globalRedisClient;
+  if (app == null ? void 0 : app.redisConnectionManager) {
+    const conn = app.redisConnectionManager.getConnection();
+    if (conn) return conn;
+  }
+  const url = process.env.REDIS_URL || process.env.CACHE_REDIS_URL || process.env.PUBSUB_ADAPTER_REDIS_URL;
+  if (!url) return null;
+  globalRedisClient = (0, import_redis.createClient)({ url });
+  globalRedisClient.connect().catch((err) => {
+    console.error("[ClusterManager] Redis fallback connection error:", err);
+  });
+  return globalRedisClient;
+}
+function getRedis(ctx) {
+  return getRedisClient(ctx.app);
+}
+function getRedisOrThrow(ctx) {
+  var _a;
+  const conn = (_a = ctx.app.redisConnectionManager) == null ? void 0 : _a.getConnection();
+  if (!conn) {
+    ctx.throw(503, "Redis is not configured or not connected");
+  }
+  return conn;
+}
+async function scanKeys(redis, pattern, batchSize = 200) {
+  const keys = [];
+  let cursor = "0";
+  do {
+    const result = await redis.sendCommand([
+      "SCAN",
+      cursor,
+      "MATCH",
+      pattern,
+      "COUNT",
+      String(batchSize)
+    ]);
+    cursor = String(result[0]);
+    if (Array.isArray(result[1])) {
+      keys.push(...result[1]);
+    }
+  } while (cursor !== "0");
+  return keys;
+}
+async function deleteKeysChunked(redis, keys, chunkSize = 500) {
+  let deleted = 0;
+  for (let i = 0; i < keys.length; i += chunkSize) {
+    const chunk = keys.slice(i, i + chunkSize);
+    if (chunk.length > 0) {
+      try {
+        const result = await redis.sendCommand(["DEL", ...chunk]);
+        deleted += Number(result) || 0;
+      } catch {
+      }
+    }
+  }
+  return deleted;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deleteKeysChunked,
+  getRedis,
+  getRedisClient,
+  getRedisOrThrow,
+  scanKeys
+});

package/dist/shared/packages.d.ts

@@ -0,0 +1,23 @@
+export declare const DEFAULT_WORKER_PACKAGES: {
+    apt: string[];
+    python: string[];
+    npm: string[];
+};
+export interface WorkerPackageMap {
+    apt?: string[];
+    npm?: string[];
+    python?: string[];
+}
+export interface CustomPackageMap {
+    python?: string[];
+    node?: string[];
+    npm?: string[];
+}
+export declare function normalizePackages(packages?: Array<string | undefined>): string[];
+export declare function parsePackageText(value: unknown, fallback?: string[]): string[];
+export declare function formatPackageText(packages?: string[]): string;
+export declare function packagesFromConfig(config: {
+    aptPackages?: unknown;
+    pythonPackages?: unknown;
+    npmPackages?: unknown;
+}): WorkerPackageMap;

package/dist/shared/packages.js

@@ -0,0 +1,70 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var packages_exports = {};
+__export(packages_exports, {
+  DEFAULT_WORKER_PACKAGES: () => DEFAULT_WORKER_PACKAGES,
+  formatPackageText: () => formatPackageText,
+  normalizePackages: () => normalizePackages,
+  packagesFromConfig: () => packagesFromConfig,
+  parsePackageText: () => parsePackageText
+});
+module.exports = __toCommonJS(packages_exports);
+const DEFAULT_WORKER_PACKAGES = {
+  apt: ["python3", "python3-pip", "python3-venv"],
+  python: [
+    "python-docx",
+    "openpyxl",
+    "pandas",
+    "matplotlib",
+    "Pillow",
+    "reportlab",
+    "jinja2",
+    "pyyaml",
+    "tabulate",
+    "xlsxwriter"
+  ],
+  npm: ["xlsx", "docx", "pdfkit", "csv-parse", "archiver", "sharp", "lodash", "dayjs"]
+};
+function normalizePackages(packages) {
+  if (!Array.isArray(packages)) return [];
+  return Array.from(new Set(packages.filter((pkg) => typeof pkg === "string").map((pkg) => pkg.trim()).filter(Boolean)));
+}
+function parsePackageText(value, fallback = []) {
+  if (Array.isArray(value)) return normalizePackages(value);
+  if (typeof value !== "string") return normalizePackages(fallback);
+  const parsed = value.split(/[\n,]/).map((pkg) => pkg.trim()).filter(Boolean);
+  return normalizePackages(parsed);
+}
+function formatPackageText(packages) {
+  return normalizePackages(packages).join("\n");
+}
+function packagesFromConfig(config) {
+  return {
+    apt: parsePackageText(config.aptPackages, DEFAULT_WORKER_PACKAGES.apt),
+    python: parsePackageText(config.pythonPackages, DEFAULT_WORKER_PACKAGES.python),
+    npm: parsePackageText(config.npmPackages, DEFAULT_WORKER_PACKAGES.npm)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_WORKER_PACKAGES,
+  formatPackageText,
+  normalizePackages,
+  packagesFromConfig,
+  parsePackageText
+});

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "plugin-cluster-manager",
+  "displayName": "Cluster Manager",
+  "displayName.zh-CN": "Cluster Manager",
+  "description": "Cluster node tracking, task orchestration, worker management, and package distribution",
+  "version": "1.0.12",
+  "license": "Apache-2.0",
+  "main": "./dist/server/index.js",
+  "keywords": ["Monitoring", "DevOps"],
+  "files": [
+    "dist",
+    "src",
+    "client.js",
+    "server.js",
+    "client.d.ts",
+    "server.d.ts"
+  ],
+  "peerDependencies": {
+    "@nocobase/client": "2.x",
+    "@nocobase/server": "2.x",
+    "@nocobase/database": "2.x"
+  },
+  "dependencies": {
+    "@nocobase/lock-manager": "2.x",
+    "@kubernetes/client-node": "^0.22.3",
+    "dockerode": "^3.3.5",
+    "redis": "^5.10.0",
+    "redlock": "5.0.0-beta.2",
+    "uuid": "^9.0.1"
+  },
+  "nocobase": {
+    "supportedVersions": ["2.x"],
+    "editionLevel": 0
+  }
+}

package/server.d.ts

@@ -0,0 +1 @@
+export * from './dist/server';

package/src/client/AclCacheManager.tsx

@@ -0,0 +1,287 @@
+import React, { useEffect, useState, useCallback } from 'react';
+import {
+  Card,
+  Row,
+  Col,
+  Statistic,
+  Table,
+  Tag,
+  Button,
+  Space,
+  Popconfirm,
+  message,
+  Typography,
+  Select,
+} from 'antd';
+import {
+  ReloadOutlined,
+  DeleteOutlined,
+  SafetyCertificateOutlined,
+  ThunderboltOutlined,
+  CheckCircleOutlined,
+  CloseCircleOutlined,
+} from '@ant-design/icons';
+import { useAPIClient } from '@nocobase/client';
+import { useT } from './utils';
+
+const { Text } = Typography;
+
+interface AclStats {
+  totalChecks: number;
+  cacheHits: number;
+  cacheMisses: number;
+  hitRate: number;
+  cachedKeys: number;
+  ttlSeconds: number;
+  startedAt: string;
+  detailByRole: Record<string, { checks: number; hits: number; misses: number }>;
+}
+
+interface CachedKey {
+  key: string;
+  role: string;
+  resource: string;
+  action: string;
+}
+
+export function AclCacheManager() {
+  const api = useAPIClient();
+  const t = useT();
+  const [stats, setStats] = useState<AclStats | null>(null);
+  const [keys, setKeys] = useState<CachedKey[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [autoRefresh, setAutoRefresh] = useState<number | null>(null);
+
+  const fetchAll = useCallback(async () => {
+    setLoading(true);
+    try {
+      const [statsRes, keysRes] = await Promise.all([
+        api.request({ url: 'clusterManagerAclCache:stats' }),
+        api.request({ url: 'clusterManagerAclCache:listKeys' }),
+      ]);
+      const statsData = statsRes?.data?.data || statsRes?.data || {};
+      setStats(statsData);
+      const keysArray = Array.isArray(keysRes?.data?.data?.data) ? keysRes.data.data.data : Array.isArray(keysRes?.data?.data) ? keysRes.data.data : Array.isArray(keysRes?.data) ? keysRes.data : [];
+      setKeys(keysArray);
+    } catch {
+      message.error('Failed to load ACL cache data');
+    } finally {
+      setLoading(false);
+    }
+  }, [api]);
+
+  useEffect(() => {
+    fetchAll();
+  }, []);
+
+  useEffect(() => {
+    if (!autoRefresh) return;
+    const timer = setInterval(fetchAll, autoRefresh * 1000);
+    return () => clearInterval(timer);
+  }, [autoRefresh, fetchAll]);
+
+  const handleClearAll = async () => {
+    try {
+      const res = await api.request({ url: 'clusterManagerAclCache:clear', method: 'post' });
+      message.success(`Cleared ${res.data?.deletedCount || 0} cache entries`);
+      fetchAll();
+    } catch {
+      message.error('Failed to clear cache');
+    }
+  };
+
+  const handleResetStats = async () => {
+    try {
+      await api.request({ url: 'clusterManagerAclCache:resetStats', method: 'post' });
+      message.success('Stats reset');
+      fetchAll();
+    } catch {
+      message.error('Failed to reset stats');
+    }
+  };
+
+  const handleClearRole = async (roleName: string) => {
+    try {
+      const res = await api.request({
+        url: 'clusterManagerAclCache:clearRole',
+        method: 'post',
+        data: { roleName },
+      });
+      message.success(`Cleared ${res.data?.deletedCount || 0} entries for role "${roleName}"`);
+      fetchAll();
+    } catch {
+      message.error('Failed to clear role cache');
+    }
+  };
+
+  if (!stats) return null;
+
+  const detailByRole = stats.detailByRole || {};
+  const roleData = Object.entries(detailByRole).map(([role, data]) => ({
+    role,
+    ...data,
+    hitRate: data.checks > 0 ? Math.round((data.hits / data.checks) * 10000) / 100 : 0,
+  }));
+
+  const keyColumns = [
+    { title: t('Role'), dataIndex: 'role', width: 120, filters: [...new Set(keys.map((k) => k.role))].map((r) => ({ text: r, value: r })), onFilter: (value: any, record: CachedKey) => record.role === value },
+    { title: t('Resource'), dataIndex: 'resource', width: 200 },
+    { title: t('Action'), dataIndex: 'action', width: 120 },
+    {
+      title: t('Cache Key'),
+      dataIndex: 'key',
+      ellipsis: true,
+      render: (val: string) => <Text code style={{ fontSize: 11 }}>{val}</Text>,
+    },
+  ];
+
+  const roleColumns = [
+    { title: t('Role'), dataIndex: 'role', width: 150 },
+    { title: t('Checks'), dataIndex: 'checks', width: 100, sorter: (a: any, b: any) => a.checks - b.checks },
+    {
+      title: t('Hits'),
+      dataIndex: 'hits',
+      width: 100,
+      render: (val: number) => <Text type="success">{val}</Text>,
+    },
+    {
+      title: t('Misses'),
+      dataIndex: 'misses',
+      width: 100,
+      render: (val: number) => <Text type="danger">{val}</Text>,
+    },
+    {
+      title: t('Hit Rate'),
+      dataIndex: 'hitRate',
+      width: 100,
+      render: (val: number) => (
+        <Tag color={val > 80 ? 'green' : val > 50 ? 'orange' : 'red'}>{val}%</Tag>
+      ),
+      sorter: (a: any, b: any) => a.hitRate - b.hitRate,
+    },
+    {
+      title: t('Actions'),
+      width: 80,
+      render: (_: any, record: any) => (
+        <Popconfirm title={`${t('Clear cache for role')} "${record.role}"?`} onConfirm={() => handleClearRole(record.role)}>
+          <Button type="link" size="small" icon={<DeleteOutlined />} danger />
+        </Popconfirm>
+      ),
+    },
+  ];
+
+  return (
+    <div>
+      <Space style={{ marginBottom: 16 }}>
+        <Button icon={<ReloadOutlined />} onClick={fetchAll} loading={loading}>
+          {t('Refresh')}
+        </Button>
+        <Select
+          placeholder={t('Auto refresh')}
+          allowClear
+          style={{ width: 160 }}
+          value={autoRefresh}
+          onChange={setAutoRefresh}
+          options={[
+            { value: 5, label: t('Every 5s') },
+            { value: 10, label: t('Every 10s') },
+            { value: 30, label: t('Every 30s') },
+          ]}
+        />
+        <Popconfirm title={t('Clear all ACL cache entries?')} onConfirm={handleClearAll}>
+          <Button icon={<DeleteOutlined />} danger>
+            {t('Clear All Cache')}
+          </Button>
+        </Popconfirm>
+        <Popconfirm title={t('Reset ACL stats counters?')} onConfirm={handleResetStats}>
+          <Button>{t('Reset Stats')}</Button>
+        </Popconfirm>
+        <Tag>TTL: {stats.ttlSeconds}s</Tag>
+        <Tag>{t('Since')}: {new Date(stats.startedAt).toLocaleString()}</Tag>
+      </Space>
+
+      {/* Overview stats */}
+      <Row gutter={[16, 16]}>
+        <Col span={6}>
+          <Card size="small">
+            <Statistic
+              title={t('Total ACL Checks')}
+              value={stats.totalChecks}
+              prefix={<SafetyCertificateOutlined />}
+            />
+          </Card>
+        </Col>
+        <Col span={6}>
+          <Card size="small">
+            <Statistic
+              title={t('Cache Hits')}
+              value={stats.cacheHits}
+              prefix={<CheckCircleOutlined />}
+              valueStyle={{ color: '#3f8600' }}
+            />
+          </Card>
+        </Col>
+        <Col span={6}>
+          <Card size="small">
+            <Statistic
+              title={t('Cache Misses')}
+              value={stats.cacheMisses}
+              prefix={<CloseCircleOutlined />}
+              valueStyle={{ color: '#cf1322' }}
+            />
+          </Card>
+        </Col>
+        <Col span={6}>
+          <Card size="small">
+            <Statistic
+              title={t('Hit Rate')}
+              value={stats.hitRate}
+              suffix="%"
+              prefix={<ThunderboltOutlined />}
+              valueStyle={{
+                color: stats.hitRate > 80 ? '#3f8600' : stats.hitRate > 50 ? '#faad14' : '#cf1322',
+              }}
+            />
+            <Text type="secondary">{t('Cached keys')}: {stats.cachedKeys}</Text>
+          </Card>
+        </Col>
+      </Row>
+
+      {/* Per-role breakdown */}
+      <Row gutter={[16, 16]} style={{ marginTop: 16 }}>
+        <Col span={12}>
+          <Card title={t('Stats by Role')} size="small">
+            {roleData.length === 0 ? (
+              <Text type="secondary">{t('No ACL checks recorded yet')}</Text>
+            ) : (
+              <Table
+                rowKey="role"
+                size="small"
+                pagination={false}
+                dataSource={roleData}
+                columns={roleColumns}
+              />
+            )}
+          </Card>
+        </Col>
+
+        {/* Cached keys */}
+        <Col span={12}>
+          <Card title={`${t('Cached Permission Keys')} (${keys.length})`} size="small">
+            {keys.length === 0 ? (
+              <Text type="secondary">{t('No cached keys')}</Text>
+            ) : (
+              <Table
+                rowKey="key"
+                size="small"
+                pagination={{ pageSize: 10, size: 'small' }}
+                dataSource={keys}
+                columns={keyColumns}
+              />
+            )}
+          </Card>
+        </Col>
+      </Row>
+    </div>
+  );
+}

package/src/client/CacheMonitor.tsx

@@ -0,0 +1,179 @@
+import React, { useState, useEffect, useCallback } from 'react';
+import { Card, Table, Tag, Button, Space, Row, Col, Statistic, Tabs, Spin, Popconfirm, message } from 'antd';
+import {
+  ReloadOutlined,
+  DatabaseOutlined,
+  DeleteOutlined,
+} from '@ant-design/icons';
+import { useAPIClient } from '@nocobase/client';
+import { AclCacheManager } from './AclCacheManager';
+import { RedisMonitor } from './RedisMonitor';
+import { LockMonitor } from './LockMonitor';
+import { EventQueueMonitor } from './EventQueueMonitor';
+import { useT } from './utils';
+
+export function CacheMonitor() {
+  const t = useT();
+  const api = useAPIClient();
+  const [loading, setLoading] = useState(false);
+  const [stores, setStores] = useState<any[]>([]);
+  const [caches, setCaches] = useState<any[]>([]);
+  const [redisMemory, setRedisMemory] = useState<any>(null);
+
+  const fetchData = useCallback(async () => {
+    setLoading(true);
+    try {
+      const [storesRes, cachesRes, memRes] = await Promise.all([
+        api.request({ url: 'clusterManagerCacheMgr:stores' }),
+        api.request({ url: 'clusterManagerCacheMgr:caches' }),
+        api.request({ url: 'clusterManagerCacheMgr:redisMemory' }),
+      ]);
+      setStores(storesRes?.data?.data?.data || []);
+      setCaches(cachesRes?.data?.data?.data || []);
+      setRedisMemory(memRes?.data?.data);
+    } catch {
+      // Ignore
+    } finally {
+      setLoading(false);
+    }
+  }, [api]);
+
+  useEffect(() => {
+    fetchData();
+  }, [fetchData]);
+
+  const handleFlushAll = async () => {
+    try {
+      await api.request({ url: 'clusterManagerCacheMgr:flushAll', method: 'post' });
+      message.success(t('All caches flushed'));
+      fetchData();
+    } catch {
+      message.error(t('Failed to flush caches'));
+    }
+  };
+
+  const storeColumns = [
+    { title: t('Store Name'), dataIndex: 'name', key: 'name' },
+    {
+      title: t('Type'),
+      dataIndex: 'type',
+      key: 'type',
+      width: 120,
+      render: (v: string) => <Tag color={v === 'redis' ? 'blue' : 'default'}>{v}</Tag>,
+    },
+    {
+      title: t('Default'),
+      dataIndex: 'isDefault',
+      key: 'isDefault',
+      width: 100,
+      render: (v: boolean) => (v ? <Tag color="green">Yes</Tag> : '-'),
+    },
+  ];
+
+  const cacheColumns = [
+    { title: t('Cache Name'), dataIndex: 'name', key: 'name' },
+    {
+      title: t('Prefix'),
+      dataIndex: 'prefix',
+      key: 'prefix',
+      render: (v: string | null) => (v ? <code style={{ fontSize: 11 }}>{v}</code> : '-'),
+    },
+  ];
+
+  return (
+    <Tabs
+      defaultActiveKey="overview"
+      items={[
+        {
+          key: 'overview',
+          label: t('Cache Stores'),
+          children: (
+            <Spin spinning={loading}>
+              <Space direction="vertical" style={{ width: '100%' }} size="middle">
+                <Space>
+                  <Button icon={<ReloadOutlined />} onClick={fetchData}>{t('Refresh')}</Button>
+                  <Popconfirm
+                    title={t('Flush all caches?')}
+                    description={t('This will clear all cached data across all stores.')}
+                    onConfirm={handleFlushAll}
+                  >
+                    <Button danger icon={<DeleteOutlined />}>{t('Flush All')}</Button>
+                  </Popconfirm>
+                </Space>
+
+                <Row gutter={16}>
+                  <Col span={8}>
+                    <Card size="small">
+                      <Statistic
+                        title={t('Cache Stores')}
+                        value={stores.length}
+                        prefix={<DatabaseOutlined />}
+                      />
+                    </Card>
+                  </Col>
+                  <Col span={8}>
+                    <Card size="small">
+                      <Statistic
+                        title={t('Named Caches')}
+                        value={caches.length}
+                      />
+                    </Card>
+                  </Col>
+                  <Col span={8}>
+                    <Card size="small">
+                      <Statistic
+                        title={t('Redis Keys')}
+                        value={redisMemory?.available ? redisMemory.totalKeys : '-'}
+                        suffix={redisMemory?.available ? `(${redisMemory.usedMemory})` : ''}
+                      />
+                    </Card>
+                  </Col>
+                </Row>
+
+                <Card title={t('Registered Stores')} size="small">
+                  <Table
+                    dataSource={stores}
+                    columns={storeColumns}
+                    rowKey="name"
+                    size="small"
+                    pagination={false}
+                  />
+                </Card>
+
+                <Card title={t('Named Caches')} size="small">
+                  <Table
+                    dataSource={caches}
+                    columns={cacheColumns}
+                    rowKey="name"
+                    size="small"
+                    pagination={false}
+                  />
+                </Card>
+              </Space>
+            </Spin>
+          ),
+        },
+        {
+          key: 'acl',
+          label: t('ACL Cache'),
+          children: <AclCacheManager />,
+        },
+        {
+          key: 'redis',
+          label: t('Redis Monitor'),
+          children: <RedisMonitor />,
+        },
+        {
+          key: 'locks',
+          label: t('Locks'),
+          children: <LockMonitor />,
+        },
+        {
+          key: 'queue',
+          label: t('Event Queue'),
+          children: <EventQueueMonitor />,
+        },
+      ]}
+    />
+  );
+}