@onlineapps/conn-orch-registry 1.1.21 → 1.1.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/conn-orch-registry",
-    "version": "1.1.21",
+    "version": "1.1.23",
   "license": "MIT",
   "description": "Connector-registry-client provides the core communication mechanism for microservices in this environment. It enables them to interact with a services_registry to receive and fulfill tasks by submitting heartbeats or their API descriptions.",
   "keywords": [
@@ -39,6 +39,7 @@
   },
   "dependencies": {
     "@onlineapps/conn-base-storage": "^1.0.0",
+    "@onlineapps/mq-client-core": "^1.0.26",
     "amqplib": "^0.10.9",
     "axios": "^1.12.2",
     "dotenv": "^16.6.1",

package/src/queueManager.js

@@ -19,6 +19,7 @@
  */
 
 const amqp = require('amqplib');
+const queueConfig = require('@onlineapps/mq-client-core/src/config/queueConfig');
 
 /**
  * Queue manager for the microservice connector.
@@ -59,28 +60,46 @@ class QueueManager {
     }
 
     // Default queues for the registry client
-    const baseQueues = [
-      'workflow'
-      // Note: ${serviceName}.registry queue is created by RegistryEventConsumer when needed
-    ];
+    const baseQueues = [];
 
     const queuesToCreate = baseQueues.concat(additionalQueues);
 
     for (const q of queuesToCreate) {
-      // Use checkQueue first to avoid 406 PRECONDITION-FAILED closing the channel
-      // If queue doesn't exist (404), then assertQueue to create it
-      try {
-        await this.channel.checkQueue(q);
-        // Queue exists - continue
-      } catch (checkErr) {
-        // If queue doesn't exist (404), create it with default options
-        if (checkErr.code === 404) {
-          await this.channel.assertQueue(q, { durable: true });
-        } else {
-          // Other error (including 406) - queue exists with different args
-          // Log warning and continue without asserting
-          console.warn(`[QueueManager] Queue ${q} exists with different arguments, using as-is:`, checkErr.message);
+      console.log(`[QueueManager] [REGISTRY] [QUEUE] Ensuring queue: ${q} at ${new Date().toISOString()}`);
+      
+      // CRITICAL: Use queueConfig.js to get correct parameters (TTL, max-length, etc.)
+      // This prevents 406 PRECONDITION-FAILED errors from TTL mismatches
+      let queueOptions = { durable: true };
+      
+      if (queueConfig) {
+        try {
+          if (queueConfig.isInfrastructureQueue(q)) {
+            const infraConfig = queueConfig.getInfrastructureQueueConfig(q);
+            queueOptions = {
+              durable: infraConfig.durable !== false,
+              arguments: { ...infraConfig.arguments }
+            };
+            console.log(`[QueueManager] [REGISTRY] [QUEUE] Using infrastructure queue config for ${q}:`, JSON.stringify(queueOptions));
+          } else {
+            console.warn(`[QueueManager] [REGISTRY] [QUEUE] Queue ${q} is not an infrastructure queue, using default options`);
+          }
+        } catch (configErr) {
+          console.warn(`[QueueManager] [REGISTRY] [QUEUE] Failed to get config for ${q}, using defaults:`, configErr.message);
         }
+      } else {
+        console.warn(`[QueueManager] [REGISTRY] [QUEUE] queueConfig not available, using default options for ${q}`);
+      }
+      
+      // Directly assert queue with canonical configuration (idempotent)
+      try {
+        const assertStartTime = Date.now();
+        await this.channel.assertQueue(q, queueOptions);
+        const assertEndTime = Date.now();
+        console.log(`[QueueManager] [REGISTRY] [QUEUE] ✓ Queue ${q} asserted (took ${assertEndTime - assertStartTime}ms)`);
+      } catch (assertErr) {
+        console.error(`[QueueManager] [REGISTRY] [QUEUE] ✗ Failed to assert queue ${q}:`, assertErr.message);
+        console.error(`[QueueManager] [REGISTRY] [QUEUE] Error code: ${assertErr.code}`);
+        throw assertErr;
       }
     }
   }

package/src/registryClient.js

@@ -19,6 +19,8 @@ const EventEmitter = require('events');
 const QueueManager = require('./queueManager');
 const RegistryEventConsumer = require('./registryEventConsumer');
 const { v4: uuidv4 } = require('uuid');
+const queueConfig = require('@onlineapps/mq-client-core/src/config/queueConfig');
+
 
 class ServiceRegistryClient extends EventEmitter {
   /**
@@ -55,6 +57,7 @@ class ServiceRegistryClient extends EventEmitter {
 
     // Validation proof (injected via constructor - DEPENDENCY INJECTION)
     this.validationProof = validationProof;
+    this._verifiedInfraQueues = new Set();
   }
 
   /**
@@ -78,9 +81,16 @@ class ServiceRegistryClient extends EventEmitter {
     // Create service-specific registry event queue (for certificate delivery)
     this.serviceRegistryQueue = `${this.serviceName}.registry`;
 
-    // Ensure existence of API, registry and service response queues
-    await this.queueManager.ensureQueues([this.apiQueue, this.registryQueue, this.serviceResponseQueue, this.serviceRegistryQueue]);
+    // Ensure existence of service-specific queues only (infrastructure queues must already exist)
+    await this.queueManager.ensureQueues([this.serviceResponseQueue, this.serviceRegistryQueue]);
 
+    // CRITICAL: Before consume(), we must assertQueue with correct parameters
+    // amqplib's channel.consume() may internally call assertQueue() WITHOUT parameters
+    // This causes 406 PRECONDITION-FAILED if queue exists with different arguments
+    console.log(`[RegistryClient] [CONSUMER] About to consume from ${this.serviceResponseQueue}`);
+    console.log(`[RegistryClient] [CONSUMER] ⚠ WARNING: amqplib's channel.consume() may internally call assertQueue() WITHOUT parameters`);
+    console.log(`[RegistryClient] [CONSUMER] ⚠ WARNING: Queue should already be asserted by ensureQueues() above with correct parameters from queueConfig.js`);
+    
     // Start consuming service response queue for registry responses
     await this.queueManager.channel.consume(
       this.serviceResponseQueue,
@@ -96,6 +106,10 @@ class ServiceRegistryClient extends EventEmitter {
     );
 
     // CRITICAL: Also listen on registry event queue for certificate delivery
+    console.log(`[RegistryClient] [CONSUMER] About to consume from ${this.serviceRegistryQueue}`);
+    console.log(`[RegistryClient] [CONSUMER] ⚠ WARNING: amqplib's channel.consume() may internally call assertQueue() WITHOUT parameters`);
+    console.log(`[RegistryClient] [CONSUMER] ⚠ WARNING: Queue should already be asserted by ensureQueues() above with correct parameters from queueConfig.js`);
+    
     await this.queueManager.channel.consume(
       this.serviceRegistryQueue,
       msg => {
@@ -190,6 +204,49 @@ class ServiceRegistryClient extends EventEmitter {
     }
   }
 
+  /**
+   * Ensure an infrastructure queue exists without mutating it.
+   * Uses a temporary channel so failures don't kill the primary channel.
+   * @param {string} queueName
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _ensureInfrastructureQueue(queueName) {
+    if (!queueName) {
+      return;
+    }
+
+    if (!queueConfig?.isInfrastructureQueue(queueName)) {
+      return;
+    }
+
+    if (this._verifiedInfraQueues.has(queueName)) {
+      return;
+    }
+
+    if (!this.queueManager?.conn) {
+      console.warn(`[RegistryClient] ${this.serviceName}: MQ connection not ready, cannot verify infrastructure queue ${queueName}`);
+      return;
+    }
+
+    const verificationChannel = await this.queueManager.conn.createChannel();
+    try {
+      await verificationChannel.checkQueue(queueName);
+      this._verifiedInfraQueues.add(queueName);
+    } catch (error) {
+      if (error.code === 404) {
+        throw new Error(`[RegistryClient] Infrastructure queue '${queueName}' is missing. Ensure the responsible infrastructure service has initialized it.`);
+      }
+      throw error;
+    } finally {
+      try {
+        await verificationChannel.close();
+      } catch (closeErr) {
+        console.warn(`[RegistryClient] ${this.serviceName}: Failed to close verification channel for ${queueName}:`, closeErr.message);
+      }
+    }
+  }
+
   /**
    * Registers the service with the registry.
    * Registry will validate if the service is properly tested and valid.
@@ -263,15 +320,10 @@ class ServiceRegistryClient extends EventEmitter {
     }
 
     // Send registration message to registry
-    // Use checkQueue to avoid 406 PRECONDITION-FAILED closing the channel
-    try {
-      await this.queueManager.channel.checkQueue(this.registryQueue);
-    } catch (checkErr) {
-      if (checkErr.code === 404) {
-        await this.queueManager.channel.assertQueue(this.registryQueue, { durable: true });
-      }
-      // If 406 or other error, queue exists - proceed to publish
-    }
+    // CRITICAL: Use queueConfig.js to get correct parameters (TTL, max-length, etc.)
+    // This prevents 406 PRECONDITION-FAILED errors from TTL mismatches
+    console.log(`[RegistryClient] [PUBLISH] Preparing to publish to ${this.registryQueue}`);
+    await this._ensureInfrastructureQueue(this.registryQueue);
     console.log(`[RegistryClient] ${this.serviceName}: Sending registration message to queue: ${this.registryQueue}`);
     console.log(`[RegistryClient] ${this.serviceName}: Message type: ${msg.type}, serviceName: ${msg.serviceName}, version: ${msg.version}`);
     this.queueManager.channel.sendToQueue(
@@ -311,14 +363,9 @@ class ServiceRegistryClient extends EventEmitter {
     };
 
     // Send deregistration message to registry
-    // Use checkQueue to avoid 406 PRECONDITION-FAILED closing the channel
-    try {
-      await this.queueManager.channel.checkQueue(this.registryQueue);
-    } catch (checkErr) {
-      if (checkErr.code === 404) {
-        await this.queueManager.channel.assertQueue(this.registryQueue, { durable: true });
-      }
-    }
+    // CRITICAL: Use queueConfig.js to get correct parameters (TTL, max-length, etc.)
+    console.log(`[RegistryClient] [PUBLISH] Preparing to publish to ${this.registryQueue} (deregister)`);
+    await this._ensureInfrastructureQueue(this.registryQueue);
     this.queueManager.channel.sendToQueue(
       this.registryQueue,
       Buffer.from(JSON.stringify(msg)),
@@ -361,14 +408,9 @@ class ServiceRegistryClient extends EventEmitter {
       specificationEndpoint: this.specificationEndpoint,
       timestamp: new Date().toISOString()
     };
-    // Use checkQueue to avoid 406 PRECONDITION-FAILED closing the channel
-    try {
-      await this.queueManager.channel.checkQueue(this.registryQueue);
-    } catch (checkErr) {
-      if (checkErr.code === 404) {
-        await this.queueManager.channel.assertQueue(this.registryQueue, { durable: true });
-      }
-    }
+    // CRITICAL: Use queueConfig.js to get correct parameters (TTL, max-length, etc.)
+    console.log(`[RegistryClient] [PUBLISH] Preparing to publish to ${this.registryQueue} (heartbeat)`);
+    await this._ensureInfrastructureQueue(this.registryQueue);
     this.queueManager.channel.sendToQueue(
       this.registryQueue,
       Buffer.from(JSON.stringify(msg)),
@@ -412,14 +454,9 @@ class ServiceRegistryClient extends EventEmitter {
       description: apiDescription,
       timestamp: new Date().toISOString()
     };
-    // Use checkQueue to avoid 406 PRECONDITION-FAILED closing the channel
-    try {
-      await this.queueManager.channel.checkQueue(this.registryQueue);
-    } catch (checkErr) {
-      if (checkErr.code === 404) {
-        await this.queueManager.channel.assertQueue(this.registryQueue, { durable: true });
-      }
-    }
+    // CRITICAL: Use queueConfig.js to get correct parameters (TTL, max-length, etc.)
+    console.log(`[RegistryClient] [PUBLISH] Preparing to publish to ${this.registryQueue} (apiDescription)`);
+    await this._ensureInfrastructureQueue(this.registryQueue);
     this.queueManager.channel.sendToQueue(
       this.registryQueue,
       Buffer.from(JSON.stringify(msg)),