plugin-cluster-manager 1.1.11 → 1.1.15

package/src/server/adapters/redis-node-registry.ts

@@ -1,131 +1,126 @@
-import os from 'os';
-import { scanKeys, getRedisClient } from '../utils/redis';
-import { getLocalNodeId } from '../utils/node';
-
-export class RedisNodeRegistry {
-  private timer: NodeJS.Timeout | null = null;
-  private readonly ttlSecs = 30; // 30 seconds TTL
-  private readonly intervalMs = 10000; // Heartbeat every 10 seconds
-  private readonly keyPrefix = 'cluster-manager:nodes:';
-
-  constructor(private app: any) {}
-
-  public start() {
-    if (this.timer) {
-      clearInterval(this.timer);
-    }
-    
-    // Initial heartbeat
-    this.heartbeat();
-
-    // Loop
-    this.timer = setInterval(() => {
-      this.heartbeat();
-    }, this.intervalMs);
-  }
-
-  public stop() {
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
-  }
-
-  private async heartbeat() {
-    const redis = getRedisClient(this.app);
-    if (!redis) return;
-
-    // Unique identifier combining hostname, port, pid, mode, and appName to handle multiple workers on the same host
-    const port = process.env.APP_PORT || 'unknown';
-    const mode = process.env.WORKER_MODE || 'main';
-    const appName = process.env.APP_NAME || this.app.name || 'main';
-    const nodeId = getLocalNodeId(this.app);
-    const key = `${this.keyPrefix}${nodeId}`;
-
-    // Collect process-level metrics so any node can read another node's full info from Redis
-    const mem = process.memoryUsage();
-
-    const metadata = {
-      id: nodeId,
-      name: `${appName} (${os.hostname()})`,
-      hostname: os.hostname(),
-      appVersion: process.env.NOCOBASE_VERSION || process.version,
-      workerMode: mode,
-      isSandbox: process.env.SKILL_HUB_SANDBOX === 'true',
-      pid: process.pid,
-      url: process.env.APP_PUBLIC_URL || null,
-      available: true,
-      lastHeartbeatAt: Date.now(),
-      status: 'online', // Implicitly online since it just reported
-      // Full node details (replicated from the `current` action shape)
-      // so that any node can serve the "current" endpoint for the APP node
-      nodeDetails: {
-        node: {
-          hostname: os.hostname(),
-          pid: process.pid,
-          nodeVersion: process.version,
-          platform: process.platform,
-          arch: process.arch,
-          uptime: process.uptime(),
-          workerMode: mode,
-          appPort: port,
-          clusterMode: process.env.CLUSTER_MODE || '',
-        },
-        memory: {
-          rss: mem.rss,
-          heapUsed: mem.heapUsed,
-          heapTotal: mem.heapTotal,
-          external: mem.external,
-          arrayBuffers: mem.arrayBuffers || 0,
-        },
-        os: {
-          totalMemory: os.totalmem(),
-          freeMemory: os.freemem(),
-          cpuCount: os.cpus().length,
-          loadAvg: os.loadavg(),
-        },
-      },
-    };
-
-    try {
-      await redis.sendCommand([
-        'SET',
-        key,
-        JSON.stringify(metadata),
-        'EX',
-        this.ttlSecs.toString(),
-      ]);
-    } catch (err: any) {
-      this.app.logger.error(`[RedisNodeRegistry] Heartbeat failed: ${err.message}`);
-    }
-  }
-
-  public async getNodes(): Promise<any[]> {
-    const redis = getRedisClient(this.app);
-    if (!redis) return [];
-
-    try {
-      const rawKeys = await scanKeys(redis, `${this.keyPrefix}*`);
-      if (rawKeys.length === 0) return [];
-
-      const values = await redis.sendCommand(['MGET', ...rawKeys]);
-      
-      const nodes: any[] = [];
-      if (Array.isArray(values)) {
-        for (const val of values) {
-          if (val) {
-            try {
-              nodes.push(JSON.parse(val));
-            } catch (e) {
-              // bad JSON, ignore
-            }
-          }
-        }
-      }
-      return nodes;
-    } catch (err: any) {
-      this.app.logger.error(`[RedisNodeRegistry] Error fetching nodes: ${err.message}`);
-      return [];
-    }
-  }
-}
+import os from 'os';
+import { scanKeys, getRedisClient } from '../utils/redis';
+import { getLocalNodeId } from '../utils/node';
+
+export class RedisNodeRegistry {
+  private timer: NodeJS.Timeout | null = null;
+  private readonly ttlSecs = 30; // 30 seconds TTL
+  private readonly intervalMs = 10000; // Heartbeat every 10 seconds
+  private readonly keyPrefix = 'cluster-manager:nodes:';
+
+  constructor(private app: any) {}
+
+  public start() {
+    if (this.timer) {
+      clearInterval(this.timer);
+    }
+
+    // Initial heartbeat
+    this.heartbeat();
+
+    // Loop
+    this.timer = setInterval(() => {
+      this.heartbeat();
+    }, this.intervalMs);
+  }
+
+  public stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  private async heartbeat() {
+    const redis = getRedisClient(this.app);
+    if (!redis) return;
+
+    // Unique identifier combining hostname, port, pid, mode, and appName to handle multiple workers on the same host
+    const port = process.env.APP_PORT || 'unknown';
+    const mode = process.env.WORKER_MODE || 'main';
+    const appName = process.env.APP_NAME || this.app.name || 'main';
+    const nodeId = getLocalNodeId(this.app);
+    const key = `${this.keyPrefix}${nodeId}`;
+
+    // Collect process-level metrics so any node can read another node's full info from Redis
+    const mem = process.memoryUsage();
+
+    const metadata = {
+      id: nodeId,
+      name: `${appName} (${os.hostname()})`,
+      hostname: os.hostname(),
+      appVersion: process.env.NOCOBASE_VERSION || process.version,
+      workerMode: mode,
+      appRole: process.env.APP_ROLE,
+      isSandbox: process.env.SKILL_HUB_SANDBOX === 'true',
+      pid: process.pid,
+      url: process.env.APP_PUBLIC_URL || null,
+      available: true,
+      lastHeartbeatAt: Date.now(),
+      status: 'online', // Implicitly online since it just reported
+      // Full node details (replicated from the `current` action shape)
+      // so that any node can serve the "current" endpoint for the APP node
+      nodeDetails: {
+        node: {
+          hostname: os.hostname(),
+          pid: process.pid,
+          nodeVersion: process.version,
+          platform: process.platform,
+          arch: process.arch,
+          uptime: process.uptime(),
+          workerMode: mode,
+          appPort: port,
+          clusterMode: process.env.CLUSTER_MODE || '',
+        },
+        memory: {
+          rss: mem.rss,
+          heapUsed: mem.heapUsed,
+          heapTotal: mem.heapTotal,
+          external: mem.external,
+          arrayBuffers: mem.arrayBuffers || 0,
+        },
+        os: {
+          totalMemory: os.totalmem(),
+          freeMemory: os.freemem(),
+          cpuCount: os.cpus().length,
+          loadAvg: os.loadavg(),
+        },
+      },
+    };
+
+    try {
+      await redis.sendCommand(['SET', key, JSON.stringify(metadata), 'EX', this.ttlSecs.toString()]);
+    } catch (err: any) {
+      this.app.logger.error(`[RedisNodeRegistry] Heartbeat failed: ${err.message}`);
+    }
+  }
+
+  public async getNodes(): Promise<any[]> {
+    const redis = getRedisClient(this.app);
+    if (!redis) return [];
+
+    try {
+      const rawKeys = await scanKeys(redis, `${this.keyPrefix}*`);
+      if (rawKeys.length === 0) return [];
+
+      const values = await redis.sendCommand(['MGET', ...rawKeys]);
+
+      const nodes: any[] = [];
+      if (Array.isArray(values)) {
+        for (const val of values) {
+          if (val) {
+            try {
+              nodes.push(JSON.parse(val));
+            } catch (e) {
+              // bad JSON, ignore
+            }
+          }
+        }
+      }
+      return nodes;
+    } catch (err: any) {
+      this.app.logger.error(`[RedisNodeRegistry] Error fetching nodes: ${err.message}`);
+      return [];
+    }
+  }
+}

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/orchestrator/PackageManager.ts

@@ -1,6 +1,6 @@
 import { spawn } from 'child_process';
 import { getRedisClient } from '../utils/redis';
-import { getLocalNodeId } from '../utils/node';
+import { getLocalNodeId, getLocalRole } from '../utils/node';
 import { promises as fsp } from 'fs';
 import path from 'path';
 import Application from '@nocobase/server';
@@ -67,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 {

package/src/server/orchestrator/docker-adapter.ts

@@ -17,9 +17,7 @@ function getDockerode() {
     try {
       Dockerode = require('dockerode');
     } catch {
-      throw new Error(
-        '[DockerAdapter] "dockerode" package not found. Install it: yarn add dockerode',
-      );
+      throw new Error('[DockerAdapter] "dockerode" package not found. Install it: yarn add dockerode');
     }
   }
   return Dockerode;
@@ -58,11 +56,7 @@ export class DockerAdapter implements IOrchestratorAdapter {
     const containers = await this.docker.listContainers({
       all: true,
       filters: {
-        label: [
-          `${LABEL_STACK}=${stack.name}`,
-          `${LABEL_MANAGED}=true`,
-          ...this.buildLabelFilters(this.workerLabels),
-        ],
+        label: [`${LABEL_STACK}=${stack.name}`, `${LABEL_MANAGED}=true`, ...this.buildLabelFilters(this.workerLabels)],
       },
     });
 
@@ -105,9 +99,20 @@ export class DockerAdapter implements IOrchestratorAdapter {
     if (diff > 0) {
       // Scale UP
       let targetNetworks = stack.networks && stack.networks.length > 0 ? stack.networks : [];
-      let targetNetworkMode = stack.networkMode;
+      const targetNetworkMode = stack.networkMode;
       let targetEnvVars = this.buildEnvArray(stack.envVars);
       let targetVolumes = stack.volumes || [];
+      // Default the worker image to whatever the app container is running, so
+      // workers stay version-locked with the app even when the stack record
+      // has a stale/empty image. An explicit stack.image still wins.
+      let targetImage = stack.image;
+      // Inherit the app container's startup command/entrypoint so workers boot
+      // identically (e.g. source-tarball extraction + `yarn start`). Without
+      // this, a worker created from the bare image runs the image default
+      // command, skips the app's bootstrap, never finishes booting, and never
+      // registers a heartbeat — so it never appears in Cluster Nodes.
+      let inheritedCmd: string[] | undefined;
+      let inheritedEntrypoint: string[] | undefined;
 
       // Auto-detect current container's configuration to inherit networks and env vars
       try {
@@ -115,50 +120,70 @@ export class DockerAdapter implements IOrchestratorAdapter {
         const myContainerId = os.hostname();
         const myContainer = this.docker.getContainer(myContainerId);
         const myInfo = await myContainer.inspect();
-        
+
+        // Inherit the app container's image when the stack does not pin one
+        if (!targetImage && myInfo?.Config?.Image) {
+          targetImage = myInfo.Config.Image;
+          console.log('[DockerAdapter] Inherited image from app container:', targetImage);
+        }
+
         // Always inherit Networks so worker can communicate with main app
         if (myInfo?.NetworkSettings?.Networks) {
           const inheritedNetworks = Object.keys(myInfo.NetworkSettings.Networks);
           targetNetworks = Array.from(new Set([...inheritedNetworks, ...targetNetworks]));
           console.log('[DockerAdapter] Inherited networks:', targetNetworks);
         }
-        
+
         // Inherit Environment Variables and merge with stack.envVars
         if (myInfo?.Config?.Env) {
-           const envDict: Record<string, string> = {};
-           myInfo.Config.Env.forEach((e: string) => {
-             const idx = e.indexOf('=');
-             if (idx !== -1) {
-               envDict[e.substring(0, idx)] = e.substring(idx + 1);
-             }
-           });
-           // Overwrite with explicitly defined env vars
-           Object.assign(envDict, stack.envVars || {});
-           
-           targetEnvVars = Object.entries(envDict).map(([k, v]) => `${k}=${v}`);
+          const envDict: Record<string, string> = {};
+          myInfo.Config.Env.forEach((e: string) => {
+            const idx = e.indexOf('=');
+            if (idx !== -1) {
+              envDict[e.substring(0, idx)] = e.substring(idx + 1);
+            }
+          });
+          // Overwrite with explicitly defined env vars
+          Object.assign(envDict, stack.envVars || {});
+
+          targetEnvVars = Object.entries(envDict).map(([k, v]) => `${k}=${v}`);
         }
         // Inherit Volumes (Binds)
         if (myInfo?.HostConfig?.Binds) {
           const inheritedBinds = myInfo.HostConfig.Binds as string[];
           targetVolumes = Array.from(new Set([...inheritedBinds, ...targetVolumes]));
         }
+        // Inherit the startup Cmd/Entrypoint so the worker runs the same bootstrap
+        // as the app container (used only when the stack pins no explicit command).
+        if (Array.isArray(myInfo?.Config?.Cmd) && myInfo.Config.Cmd.length > 0) {
+          inheritedCmd = myInfo.Config.Cmd as string[];
+        }
+        if (Array.isArray(myInfo?.Config?.Entrypoint) && myInfo.Config.Entrypoint.length > 0) {
+          inheritedEntrypoint = myInfo.Config.Entrypoint as string[];
+        }
       } catch (e: any) {
         // Ignore error if not running in a container or cannot inspect
         console.error('[DockerAdapter] Failed to inherit container config:', e.message);
       }
 
       // Automatically separate logs for workers to prevent log interleaving with the main app
-      const hasLoggerBase = targetEnvVars.some(e => e.startsWith('LOGGER_BASE_PATH='));
+      const hasLoggerBase = targetEnvVars.some((e) => e.startsWith('LOGGER_BASE_PATH='));
       if (!hasLoggerBase) {
         targetEnvVars.push(`LOGGER_BASE_PATH=/app/nocobase/storage/logs/${stack.name}`);
       }
 
+      if (!targetImage) {
+        throw new Error(
+          `[DockerAdapter] No image configured for stack "${stack.name}" and the app container image could not be determined.`,
+        );
+      }
+
       for (let i = 0; i < diff; i++) {
         const suffix = `${Date.now()}-${Math.random().toString(36).substring(2, 6)}`;
         const containerName = `${stack.name}-${suffix}`;
 
         const createOpts: any = {
-          Image: stack.image,
+          Image: targetImage,
           name: containerName,
           Env: targetEnvVars,
           Labels: {
@@ -174,6 +199,15 @@ export class DockerAdapter implements IOrchestratorAdapter {
 
         if (stack.command) {
           createOpts.Cmd = ['/bin/sh', '-c', stack.command];
+        } else {
+          // No explicit command: replay the app container's bootstrap so the
+          // worker boots NocoBase the same way and registers a heartbeat.
+          if (inheritedEntrypoint) {
+            createOpts.Entrypoint = inheritedEntrypoint;
+          }
+          if (inheritedCmd) {
+            createOpts.Cmd = inheritedCmd;
+          }
         }
 
         if (stack.resourceLimits?.memory) {
@@ -190,7 +224,7 @@ export class DockerAdapter implements IOrchestratorAdapter {
         createOpts.HostConfig.SecurityOpt = ['no-new-privileges:true'];
 
         const container = await this.docker.createContainer(createOpts);
-        
+
         // Connect to additional networks before starting
         if (targetNetworks.length > 0) {
           const startIndex = targetNetworkMode ? 0 : 1;
@@ -199,7 +233,9 @@ export class DockerAdapter implements IOrchestratorAdapter {
               const net = this.docker.getNetwork(targetNetworks[i]);
               await net.connect({ Container: container.id });
             } catch (err: any) {
-              console.warn(`[DockerAdapter] Failed to connect container ${container.id} to network ${targetNetworks[i]}: ${err.message}`);
+              console.warn(
+                `[DockerAdapter] Failed to connect container ${container.id} to network ${targetNetworks[i]}: ${err.message}`,
+              );
             }
           }
         }
@@ -209,9 +245,7 @@ export class DockerAdapter implements IOrchestratorAdapter {
       }
     } else if (diff < 0) {
       // Scale DOWN — remove newest first (LIFO)
-      const sorted = running.sort(
-        (a, b) => b.createdAt.getTime() - a.createdAt.getTime(),
-      );
+      const sorted = running.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
       const toRemove = sorted.slice(0, Math.abs(diff));
 
       for (const c of toRemove) {
@@ -334,14 +368,17 @@ export class DockerAdapter implements IOrchestratorAdapter {
       .split(',')
       .map((part) => part.trim())
       .filter(Boolean)
-      .reduce((acc, part) => {
-        const [key, ...valueParts] = part.split('=');
-        const value = valueParts.join('=');
-        if (key?.trim() && value?.trim()) {
-          acc[key.trim()] = value.trim();
-        }
-        return acc;
-      }, {} as Record<string, string>);
+      .reduce(
+        (acc, part) => {
+          const [key, ...valueParts] = part.split('=');
+          const value = valueParts.join('=');
+          if (key?.trim() && value?.trim()) {
+            acc[key.trim()] = value.trim();
+          }
+          return acc;
+        },
+        {} as Record<string, string>,
+      );
   }
 
   private labelsMatch(labels: Record<string, string>, expected: Record<string, string>): boolean {

package/src/server/plugin.ts

@@ -7,7 +7,7 @@ import { redisActions } from './actions/redis-monitor';
 import { aclCacheActions, createAclCacheMiddleware } from './actions/acl-cache';
 import { clusterActions, readLocalLogs } from './actions/cluster-nodes';
 import { getRedisClient } from './utils/redis';
-import { getLocalNodeId } from './utils/node';
+import { getLocalNodeId, isWorkerMode } from './utils/node';
 import { eventQueueActions } from './actions/event-queue-monitor';
 import { lockActions } from './actions/lock-monitor';
 import { cacheMonitorActions } from './actions/cache-monitor';
@@ -16,6 +16,7 @@ import { RedisNodeRegistry } from './adapters/redis-node-registry';
 import { RedisLockAdapter } from './adapters/redis-lock-adapter';
 import { orchestratorActions } from './actions/orchestrator';
 import { pluginOperationsActions } from './actions/plugin-operations';
+import { queueMappingsActions } from './actions/queue-mappings';
 import type { IOrchestratorAdapter } from './orchestrator/types';
 import { DockerAdapter } from './orchestrator/docker-adapter';
 import { K8sAdapter } from './orchestrator/k8s-adapter';
@@ -56,14 +57,12 @@ export class PluginClusterManagerServer extends Plugin {
     (this.app as any).on('afterStart', () => {
       this.nodeRegistry?.start();
 
-      // Automatically install packages on boot for worker nodes
-      const mode = process.env.WORKER_MODE || 'main';
+      // Automatically install packages on boot for worker / sandbox nodes
       const isWorker =
-        mode === 'worker' ||
-        mode === 'task' ||
-        mode === '*' ||
+        isWorkerMode(process.env.WORKER_MODE) ||
         process.env.APP_ROLE === 'worker' ||
-        process.env.APP_ROLE === 'sandbox';
+        process.env.APP_ROLE === 'sandbox' ||
+        process.env.SKILL_HUB_SANDBOX === 'true';
       if (isWorker) {
         setTimeout(async () => {
           try {
@@ -125,9 +124,7 @@ export class PluginClusterManagerServer extends Plugin {
 
     // Workflow hook to trace executing node
     this.app.db.on('executions.afterSave', async (model: any) => {
-      const mode = process.env.WORKER_MODE || 'main';
-      const isWorker = mode === 'worker' || mode === 'task' || mode === '*';
-      if (isWorker) {
+      if (isWorkerMode(process.env.WORKER_MODE)) {
         const id = model.get('id');
         const redis = getRedisClient(this.app);
         if (id && redis) {
@@ -332,6 +329,12 @@ export class PluginClusterManagerServer extends Plugin {
       actions: pluginOperationsActions,
     });
 
+    // Queue Mappings (queue-to-worker-stack assignments)
+    this.app.resourcer.define({
+      name: 'workerQueueMappings',
+      actions: queueMappingsActions,
+    });
+
     // Install ACL cache middleware inside the ACL chain so cached permissions are not overwritten.
     const aclCacheMiddleware = createAclCacheMiddleware(this.app);
     (this.app as any).acl.use(aclCacheMiddleware, {
@@ -380,6 +383,7 @@ export class PluginClusterManagerServer extends Plugin {
         'orchestratorStacks:*',
         'workerPackages:*',
         'clusterManagerPlugins:*',
+        'workerQueueMappings:*',
       ],
     });
 
@@ -558,8 +562,7 @@ export class PluginClusterManagerServer extends Plugin {
   }
 
   private isWorkerOnlyNode(): boolean {
-    const workerMode = process.env.WORKER_MODE || '';
-    return workerMode === 'worker' || workerMode === 'task' || workerMode === '*';
+    return isWorkerMode(process.env.WORKER_MODE);
   }
 }