plugin-cluster-manager 1.1.10 → 1.1.11

package/src/server/collections/cluster-manager-doctor-runs.ts

@@ -0,0 +1,23 @@
+import { CollectionOptions } from '@nocobase/database';
+
+export default {
+  name: 'clusterManagerDoctorRuns',
+  title: 'Cluster Manager Doctor Runs',
+  fields: [
+    { name: 'id', type: 'bigInt', autoIncrement: true, primaryKey: true },
+    { name: 'runId', type: 'string', length: 64, unique: true, allowNull: false },
+    { name: 'status', type: 'string', length: 20, defaultValue: 'running', allowNull: false },
+    { name: 'durationMs', type: 'integer', defaultValue: 120000, allowNull: false },
+    { name: 'progress', type: 'integer', defaultValue: 0, allowNull: false },
+    { name: 'startedAt', type: 'date', allowNull: false },
+    { name: 'deadlineAt', type: 'date', allowNull: false },
+    { name: 'finishedAt', type: 'date', allowNull: true },
+    { name: 'finishReason', type: 'string', length: 40, allowNull: true },
+    { name: 'startedBy', type: 'string', length: 200, allowNull: true },
+    { name: 'summary', type: 'json', allowNull: true },
+    { name: 'report', type: 'json', allowNull: true },
+    { name: 'error', type: 'text', allowNull: true },
+    { name: 'createdAt', type: 'date' },
+    { name: 'updatedAt', type: 'date' },
+  ],
+} as CollectionOptions;

package/src/server/collections/cluster-manager-doctor.ts

@@ -0,0 +1,19 @@
+/**
+ * DUMMY COLLECTION
+ * Keeps the `clusterManagerDoctor` resourcer compatible with NocoBase
+ * workflow/ACL collection lookups. Diagnostic run data lives in
+ * `clusterManagerDoctorRuns`.
+ */
+export default {
+  name: 'clusterManagerDoctor',
+  dumpRules: 'skip',
+  autoGenId: true,
+  createdAt: false,
+  updatedAt: false,
+  fields: [
+    {
+      name: 'name',
+      type: 'string',
+    },
+  ],
+};

package/src/server/hooks/cacheInvalidationHooks.ts

@@ -0,0 +1,58 @@
+import { cacheVersionManager } from '../utils/versionManager';
+
+export function registerCacheHooks(app: any) {
+  const db = app.db;
+
+  // 1. Collections & Fields changes (Metadata)
+  db.on('collections.afterSave', async () => {
+    await cacheVersionManager.incrementCollectionVersion(app);
+  });
+  db.on('collections.afterDestroy', async () => {
+    await cacheVersionManager.incrementCollectionVersion(app);
+  });
+  db.on('fields.afterSave', async () => {
+    await cacheVersionManager.incrementCollectionVersion(app);
+  });
+  db.on('fields.afterDestroy', async () => {
+    await cacheVersionManager.incrementCollectionVersion(app);
+  });
+
+  // 2. UI Schemas changes (Dynamic Layouts)
+  db.on('uiSchemas.afterSave', async () => {
+    await cacheVersionManager.incrementSchemaVersion(app);
+  });
+  db.on('uiSchemas.afterDestroy', async () => {
+    await cacheVersionManager.incrementSchemaVersion(app);
+  });
+
+  // 3. ACL, Roles & Scopes changes
+  const invalidateRole = async (model: any) => {
+    const roleName = model.get?.('roleName') || model.get?.('name');
+    if (roleName) {
+      await cacheVersionManager.incrementAclVersion(app, roleName);
+    } else {
+      await cacheVersionManager.incrementAllAclVersions(app);
+    }
+  };
+
+  db.on('roles.afterSave', invalidateRole);
+  db.on('roles.afterDestroy', invalidateRole);
+
+  db.on('rolesResources.afterSave', invalidateRole);
+  db.on('rolesResources.afterDestroy', invalidateRole);
+
+  db.on('rolesResourcesActions.afterSave', invalidateRole);
+  db.on('rolesResourcesActions.afterDestroy', invalidateRole);
+
+  db.on('rolesUsers.afterSave', invalidateRole);
+  db.on('rolesUsers.afterDestroy', invalidateRole);
+
+  db.on('scopes.afterSave', async () => {
+    await cacheVersionManager.incrementAllAclVersions(app);
+  });
+  db.on('scopes.afterDestroy', async () => {
+    await cacheVersionManager.incrementAllAclVersions(app);
+  });
+
+  app.logger.info('[ClusterManager] Cache invalidation hooks registered successfully');
+}

package/src/server/middlewares/listMetaCacheMiddleware.ts

@@ -0,0 +1,55 @@
+import { Context } from '@nocobase/actions';
+import { cacheVersionManager } from '../utils/versionManager';
+
+const LIST_META_CACHE_TTL = 1000 * 60 * 10; // 10 minutes cache duration
+
+function getErrorMessage(error: unknown) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export function createListMetaCacheMiddleware(app: any) {
+  return async function listMetaCacheMiddleware(ctx: Context, next: () => Promise<void>) {
+    const cache = app.cache;
+    // Skip caching if cache manager is not initialized or this is not collections:listMeta
+    if (!cache || ctx.action?.resourceName !== 'collections' || ctx.action?.actionName !== 'listMeta') {
+      return next();
+    }
+
+    const currentRole = ctx.state?.currentRole || 'anonymous';
+    const appName = ctx.headers['x-app'] || 'main';
+    const dataSource = ctx.headers['x-data-source'] || 'main';
+    const locale = ctx.headers['x-locale'] || ctx.headers['accept-language'] || 'en-US';
+    let cacheKey = '';
+    let version = 0;
+
+    try {
+      version = await cacheVersionManager.getCollectionVersion(app);
+      cacheKey = `nb:cache:${appName}:meta:v${version}:ds:${dataSource}:role:${currentRole}:lang:${locale}`;
+
+      // Try reading from NocoBase shared cache manager (Redis or Memory)
+      const cached = await cache.get(cacheKey);
+      if (cached !== undefined && cached !== null) {
+        ctx.body = typeof cached === 'string' ? JSON.parse(cached) : cached;
+        ctx.set?.('X-Cache', 'HIT');
+        ctx.set?.('X-Collection-Version', String(version));
+        return;
+      }
+    } catch (err) {
+      app.logger.warn(`[ClusterManager] listMeta cache read skipped: ${getErrorMessage(err)}`);
+    }
+
+    await next();
+
+    // If the response is valid, write to cache manager. This must not call next() again.
+    if (ctx.status === 200 && ctx.body && cacheKey) {
+      try {
+        const valueToCache = typeof ctx.body === 'string' ? ctx.body : JSON.stringify(ctx.body);
+        await cache.set(cacheKey, valueToCache, LIST_META_CACHE_TTL);
+        ctx.set?.('X-Cache', 'MISS');
+        ctx.set?.('X-Collection-Version', String(version));
+      } catch (err) {
+        app.logger.warn(`[ClusterManager] listMeta cache write skipped: ${getErrorMessage(err)}`);
+      }
+    }
+  };
+}

package/src/server/orchestrator/PackageManager.ts

@@ -1,5 +1,6 @@
 import { spawn } from 'child_process';
 import { getRedisClient } from '../utils/redis';
+import { getLocalNodeId } from '../utils/node';
 import { promises as fsp } from 'fs';
 import path from 'path';
 import Application from '@nocobase/server';
@@ -451,21 +452,24 @@ export class PackageManager {
       const redisClient = getRedisClient(this.app);
       const podName = process.env.POD_NAME || require('os').hostname();
       if (redisClient) {
-        const key = `orchestrator:pkg-status:${podName}`;
-        await redisClient.sendCommand([
-          'SET',
-          key,
-          JSON.stringify({
-            initStatus,
-            initProgressPercent,
-            initProgressLog,
-            lastInitAt: new Date(),
-            lastInitLog: logs.join('\n'),
-            ...extraValues,
-          }),
-          'EX',
-          '86400', // expire after 1 day
-        ]);
+        const statusPayload = JSON.stringify({
+          initStatus,
+          initProgressPercent,
+          initProgressLog,
+          lastInitAt: new Date(),
+          lastInitLog: logs.join('\n'),
+          ...extraValues,
+        });
+        const keys = [`orchestrator:pkg-status:${podName}`, `cluster-manager:pkg-status:${getLocalNodeId(this.app)}`];
+        for (const key of keys) {
+          await redisClient.sendCommand([
+            'SET',
+            key,
+            statusPayload,
+            'EX',
+            '86400', // expire after 1 day
+          ]);
+        }
       }
 
       // We can also keep the global DB record as a fallback/historical record