plugin-cluster-manager 1.1.10 → 1.1.13

package/src/server/actions/orchestrator.ts

@@ -41,7 +41,12 @@ async function getStack(ctx: Context, stackId?: number | string): Promise<StackC
   return stack.toJSON() as StackConfig;
 }
 
-async function assertManagedContainer(ctx: Context, adapter: IOrchestratorAdapter, stack: StackConfig, containerId: string) {
+async function assertManagedContainer(
+  ctx: Context,
+  adapter: IOrchestratorAdapter,
+  stack: StackConfig,
+  containerId: string,
+) {
   try {
     await adapter.assertManagedByStack(stack, containerId);
   } catch (err: any) {
@@ -87,7 +92,9 @@ export const orchestratorActions = {
           if (rawStatus && typeof rawStatus === 'string') {
             (c as any).packageStatus = JSON.parse(rawStatus);
           }
-        } catch {}
+        } catch {
+          // Redis may not be configured — skip package status
+        }
       }
     }
 
@@ -114,6 +121,10 @@ export const orchestratorActions = {
    * POST /workerOrchestrator:scale
    * Body: { stackId: 1, replicas: 3 }
    * Leader-only
+   *
+   * Before scaling, resolves queue-to-stack mappings and injects
+   * WORKER_MODE into the stack's envVars so new containers only
+   * process assigned queues.
    */
   async scale(ctx: Context, next: () => Promise<void>) {
     assertLeader(ctx);
@@ -124,6 +135,47 @@ export const orchestratorActions = {
     if (replicas < 0 || replicas > 20) ctx.throw(400, 'replicas must be between 0 and 20');
 
     const stack = await getStack(ctx, stackId);
+
+    // ── Resolve queue assignments for this stack ──
+    try {
+      const mappingsRepo = ctx.db.getRepository('workerQueueMappings');
+      if (mappingsRepo) {
+        const assigned = await mappingsRepo.find({
+          filter: {
+            stackId: stack.id,
+            enabled: true,
+          },
+        });
+
+        const queueNames = assigned.map((m: any) => m.get('queueName') as string).filter(Boolean);
+
+        if (queueNames.length > 0) {
+          const workerMode = queueNames.join(',');
+          ctx.app.logger.info(
+            `[Orchestrator] Injecting WORKER_MODE=${workerMode} for stack "${stack.name}" (${queueNames.length} queue(s) assigned)`,
+          );
+          // Merge into envVars; adapter code merges envVars over inherited env
+          stack.envVars = {
+            ...(stack.envVars || {}),
+            WORKER_MODE: workerMode,
+          };
+        } else {
+          // No specific assignment → default to all queues (backwards compatible)
+          stack.envVars = {
+            ...(stack.envVars || {}),
+            WORKER_MODE: '*',
+          };
+        }
+      }
+    } catch (err: any) {
+      // If workerQueueMappings table doesn't exist yet, fall back gracefully
+      ctx.app.logger.debug(`[Orchestrator] Queue mappings not available: ${err.message}`);
+      stack.envVars = {
+        ...(stack.envVars || {}),
+        WORKER_MODE: '*',
+      };
+    }
+
     const result = await adapter.scale(stack, Number(replicas));
 
     // Update DB

package/src/server/actions/queue-mappings.ts

@@ -0,0 +1,94 @@
+/**
+ * Queue Mappings Actions
+ *
+ * CRUD for workerQueueMappings + scanQueues action that discovers
+ * all registered queues via QueueScanner.
+ */
+
+import { Context } from '@nocobase/actions';
+import { scanQueues } from '../queue-scanner';
+
+export const queueMappingsActions = {
+  /**
+   * GET /workerQueueMappings:scanQueues
+   * Scans all registered queues (EventQueue + Redis) and merges with existing mappings.
+   */
+  async scanQueues(ctx: Context, next: () => Promise<void>) {
+    const result = await scanQueues(ctx.app);
+
+    // Load existing mappings from DB
+    const repo = ctx.db.getRepository('workerQueueMappings');
+    let existingMappings: any[] = [];
+    try {
+      existingMappings = await repo.find();
+    } catch {
+      // Table may not exist yet
+    }
+
+    const mappedNames = new Set(existingMappings.map((m) => m.get('queueName') as string));
+
+    ctx.body = {
+      discovered: result.queues,
+      total: result.total,
+      registered: existingMappings.map((m) => ({
+        id: m.get('id'),
+        queueName: m.get('queueName'),
+        label: m.get('label'),
+        stackId: m.get('stackId'),
+        enabled: m.get('enabled'),
+        type: m.get('type'),
+      })),
+      unmapped: result.queues
+        .filter((q) => !mappedNames.has(q.name))
+        .map((q) => ({
+          name: q.name,
+          type: q.type,
+          label: q.label,
+          description: q.description,
+        })),
+    };
+    await next();
+  },
+
+  /**
+   * POST /workerQueueMappings:autoMap
+   * Auto-create mappings for any discovered queues that don't have one yet.
+   * Body: { stackId?: number } — optional default stack for new mappings
+   */
+  async autoMap(ctx: Context, next: () => Promise<void>) {
+    const { stackId } = ctx.action.params.values || {};
+    const result = await scanQueues(ctx.app);
+    const repo = ctx.db.getRepository('workerQueueMappings');
+
+    let existingMappings: any[] = [];
+    try {
+      existingMappings = await repo.find();
+    } catch {
+      // Table may not exist yet
+    }
+
+    const mappedNames = new Set(existingMappings.map((m) => m.get('queueName') as string));
+    const created: string[] = [];
+
+    for (const q of result.queues) {
+      if (mappedNames.has(q.name)) continue;
+      await repo.create({
+        values: {
+          queueName: q.name,
+          label: q.label,
+          description: q.description,
+          type: q.type,
+          stackId: stackId || null,
+          enabled: true,
+        },
+      });
+      created.push(q.name);
+    }
+
+    ctx.body = {
+      created,
+      count: created.length,
+    };
+    await next();
+  },
+};

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/collections/worker-queue-mappings.ts

@@ -0,0 +1,85 @@
+/**
+ * Collection: workerQueueMappings
+ *
+ * Maps queue names to worker stacks (orchestratorStacks).
+ * When a stack has assigned queues, the orchestrator adapter sets
+ * WORKER_MODE=<comma-separated-queue-names> on new containers.
+ *
+ * If no mappings exist for a stack, WORKER_MODE=* is preserved
+ * (backwards compatibility).
+ */
+export default {
+  name: 'workerQueueMappings',
+  autoGenId: true,
+  createdAt: true,
+  updatedAt: true,
+  fields: [
+    {
+      name: 'queueName',
+      type: 'string',
+      unique: true,
+      interface: 'input',
+      uiSchema: {
+        title: 'Queue Name',
+        'x-component': 'Input',
+        required: true,
+      },
+    },
+    {
+      name: 'label',
+      type: 'string',
+      interface: 'input',
+      uiSchema: {
+        title: 'Label',
+        'x-component': 'Input',
+        description: 'Human-readable display name',
+      },
+    },
+    {
+      name: 'description',
+      type: 'text',
+      interface: 'textarea',
+      uiSchema: {
+        title: 'Description',
+        'x-component': 'Input.TextArea',
+      },
+    },
+    {
+      name: 'type',
+      type: 'string',
+      interface: 'select',
+      defaultValue: 'event-queue',
+      uiSchema: {
+        title: 'Source Type',
+        'x-component': 'Select',
+        enum: [
+          { value: 'event-queue', label: 'EventQueue' },
+          { value: 'redis-list', label: 'Redis List' },
+        ],
+      },
+    },
+    {
+      name: 'stackId',
+      type: 'integer',
+      interface: 'select',
+      uiSchema: {
+        title: 'Assigned Stack',
+        'x-component': 'Select',
+        'x-component-props': {
+          allowClear: true,
+          placeholder: 'Unassigned (worker runs all queues)',
+        },
+      },
+    },
+    {
+      name: 'enabled',
+      type: 'boolean',
+      defaultValue: true,
+      interface: 'checkbox',
+      uiSchema: {
+        title: 'Enabled',
+        'x-component': 'Checkbox',
+      },
+    },
+  ],
+};

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, getLocalRole } from '../utils/node';
 import { promises as fsp } from 'fs';
 import path from 'path';
 import Application from '@nocobase/server';
@@ -66,15 +67,7 @@ function redactUrl(value: string): string {
 }
 
 function getCurrentRole(): Exclude<TargetRole, 'all'> {
-  if (process.env.APP_ROLE === 'app' || process.env.APP_ROLE === 'worker' || process.env.APP_ROLE === 'sandbox') {
-    return process.env.APP_ROLE;
-  }
-  if (process.env.SKILL_HUB_SANDBOX === 'true') {
-    return 'sandbox';
-  }
-
-  const workerMode = process.env.WORKER_MODE || 'main';
-  return workerMode === 'worker' || workerMode === 'task' || workerMode === '*' ? 'worker' : 'app';
+  return getLocalRole();
 }
 
 function formatCommand(command: string, args: string[]): string {
@@ -451,21 +444,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