@onlineapps/conn-orch-registry 1.1.21 → 1.1.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/conn-orch-registry",
-    "version": "1.1.21",
+    "version": "1.1.22",
   "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": [

package/src/queueManager.js

@@ -19,6 +19,15 @@
  */
 
 const amqp = require('amqplib');
+// CRITICAL: Import queueConfig to ensure consistent queue parameters
+// This prevents 406 PRECONDITION-FAILED errors from TTL mismatches
+let queueConfig;
+try {
+  queueConfig = require('@onlineapps/conn-infra-mq/src/config/queueConfig');
+} catch (err) {
+  console.warn('[QueueManager] [REGISTRY] queueConfig not available, using defaults:', err.message);
+  queueConfig = null;
+}
 
 /**
  * Queue manager for the microservice connector.
@@ -67,19 +76,58 @@ class QueueManager {
     const queuesToCreate = baseQueues.concat(additionalQueues);
 
     for (const q of queuesToCreate) {
+      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}`);
+      }
+      
       // Use checkQueue first to avoid 406 PRECONDITION-FAILED closing the channel
-      // If queue doesn't exist (404), then assertQueue to create it
+      // If queue doesn't exist (404), then assertQueue to create it with correct options
       try {
+        const checkStartTime = Date.now();
         await this.channel.checkQueue(q);
+        const checkEndTime = Date.now();
+        console.log(`[QueueManager] [REGISTRY] [QUEUE] ✓ Queue ${q} exists (checkQueue took ${checkEndTime - checkStartTime}ms)`);
         // Queue exists - continue
       } catch (checkErr) {
-        // If queue doesn't exist (404), create it with default options
+        // If queue doesn't exist (404), create it with correct options from queueConfig
         if (checkErr.code === 404) {
-          await this.channel.assertQueue(q, { durable: true });
+          console.log(`[QueueManager] [REGISTRY] [QUEUE] Queue ${q} does not exist (404), creating with options:`, JSON.stringify(queueOptions));
+          const assertStartTime = Date.now();
+          try {
+            await this.channel.assertQueue(q, queueOptions);
+            const assertEndTime = Date.now();
+            console.log(`[QueueManager] [REGISTRY] [QUEUE] ✓ Created queue ${q} (assertQueue took ${assertEndTime - assertStartTime}ms)`);
+          } catch (assertErr) {
+            console.error(`[QueueManager] [REGISTRY] [QUEUE] ✗ Failed to create queue ${q}:`, assertErr.message);
+            console.error(`[QueueManager] [REGISTRY] [QUEUE] Error code: ${assertErr.code}`);
+            throw assertErr;
+          }
         } 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.warn(`[QueueManager] [REGISTRY] [QUEUE] Queue ${q} exists with different arguments, using as-is:`, checkErr.message);
+          console.warn(`[QueueManager] [REGISTRY] [QUEUE] Error code: ${checkErr.code}`);
         }
       }
     }

package/src/registryClient.js

@@ -20,6 +20,46 @@ const QueueManager = require('./queueManager');
 const RegistryEventConsumer = require('./registryEventConsumer');
 const { v4: uuidv4 } = require('uuid');
 
+// CRITICAL: Import queueConfig to ensure consistent queue parameters
+// This prevents 406 PRECONDITION-FAILED errors from TTL mismatches
+let queueConfig;
+try {
+  queueConfig = require('@onlineapps/conn-infra-mq/src/config/queueConfig');
+} catch (err) {
+  console.warn('[RegistryClient] queueConfig not available, using defaults:', err.message);
+  queueConfig = null;
+}
+
+/**
+ * Helper function to get queue options from queueConfig.js
+ * @param {string} queueName - Queue name
+ * @returns {Object} Queue options with correct parameters (TTL, max-length, etc.)
+ */
+function getQueueOptions(queueName) {
+  let queueOptions = { durable: true };
+  
+  if (queueConfig) {
+    try {
+      if (queueConfig.isInfrastructureQueue(queueName)) {
+        const infraConfig = queueConfig.getInfrastructureQueueConfig(queueName);
+        queueOptions = {
+          durable: infraConfig.durable !== false,
+          arguments: { ...infraConfig.arguments }
+        };
+        console.log(`[RegistryClient] [QUEUE] Using infrastructure queue config for ${queueName}:`, JSON.stringify(queueOptions));
+      } else {
+        console.warn(`[RegistryClient] [QUEUE] Queue ${queueName} is not an infrastructure queue, using default options`);
+      }
+    } catch (configErr) {
+      console.warn(`[RegistryClient] [QUEUE] Failed to get config for ${queueName}, using defaults:`, configErr.message);
+    }
+  } else {
+    console.warn(`[RegistryClient] [QUEUE] queueConfig not available, using default options for ${queueName}`);
+  }
+  
+  return queueOptions;
+}
+
 class ServiceRegistryClient extends EventEmitter {
   /**
    * @param {Object} opts
@@ -81,6 +121,13 @@ class ServiceRegistryClient extends EventEmitter {
     // Ensure existence of API, registry and service response queues
     await this.queueManager.ensureQueues([this.apiQueue, this.registryQueue, 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 +143,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 => {
@@ -263,14 +314,38 @@ class ServiceRegistryClient extends EventEmitter {
     }
 
     // Send registration message to registry
+    // 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}`);
+    
+    let queueOptions = { durable: true };
+    try {
+      const queueConfig = require('@onlineapps/conn-infra-mq/src/config/queueConfig');
+      if (queueConfig.isInfrastructureQueue(this.registryQueue)) {
+        const infraConfig = queueConfig.getInfrastructureQueueConfig(this.registryQueue);
+        queueOptions = {
+          durable: infraConfig.durable !== false,
+          arguments: { ...infraConfig.arguments }
+        };
+        console.log(`[RegistryClient] [PUBLISH] Using infrastructure queue config for ${this.registryQueue}:`, JSON.stringify(queueOptions));
+      }
+    } catch (configErr) {
+      console.warn(`[RegistryClient] [PUBLISH] Failed to get config for ${this.registryQueue}, using defaults:`, configErr.message);
+    }
+    
     // Use checkQueue to avoid 406 PRECONDITION-FAILED closing the channel
     try {
       await this.queueManager.channel.checkQueue(this.registryQueue);
+      console.log(`[RegistryClient] [PUBLISH] ✓ Queue ${this.registryQueue} exists`);
     } catch (checkErr) {
       if (checkErr.code === 404) {
-        await this.queueManager.channel.assertQueue(this.registryQueue, { durable: true });
+        console.log(`[RegistryClient] [PUBLISH] Queue ${this.registryQueue} does not exist (404), creating with options:`, JSON.stringify(queueOptions));
+        await this.queueManager.channel.assertQueue(this.registryQueue, queueOptions);
+        console.log(`[RegistryClient] [PUBLISH] ✓ Created queue ${this.registryQueue}`);
+      } else {
+        console.warn(`[RegistryClient] [PUBLISH] Queue ${this.registryQueue} exists with different arguments:`, checkErr.message);
+        // If 406 or other error, queue exists - proceed to publish
       }
-      // If 406 or other error, queue exists - proceed to publish
     }
     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}`);
@@ -311,12 +386,21 @@ class ServiceRegistryClient extends EventEmitter {
     };
 
     // Send deregistration message to registry
+    // CRITICAL: Use queueConfig.js to get correct parameters (TTL, max-length, etc.)
+    console.log(`[RegistryClient] [PUBLISH] Preparing to publish to ${this.registryQueue} (deregister)`);
+    const queueOptions = getQueueOptions(this.registryQueue);
+    
     // Use checkQueue to avoid 406 PRECONDITION-FAILED closing the channel
     try {
       await this.queueManager.channel.checkQueue(this.registryQueue);
+      console.log(`[RegistryClient] [PUBLISH] ✓ Queue ${this.registryQueue} exists`);
     } catch (checkErr) {
       if (checkErr.code === 404) {
-        await this.queueManager.channel.assertQueue(this.registryQueue, { durable: true });
+        console.log(`[RegistryClient] [PUBLISH] Queue ${this.registryQueue} does not exist (404), creating with options:`, JSON.stringify(queueOptions));
+        await this.queueManager.channel.assertQueue(this.registryQueue, queueOptions);
+        console.log(`[RegistryClient] [PUBLISH] ✓ Created queue ${this.registryQueue}`);
+      } else {
+        console.warn(`[RegistryClient] [PUBLISH] Queue ${this.registryQueue} exists with different arguments:`, checkErr.message);
       }
     }
     this.queueManager.channel.sendToQueue(
@@ -361,12 +445,21 @@ class ServiceRegistryClient extends EventEmitter {
       specificationEndpoint: this.specificationEndpoint,
       timestamp: new Date().toISOString()
     };
+    // CRITICAL: Use queueConfig.js to get correct parameters (TTL, max-length, etc.)
+    console.log(`[RegistryClient] [PUBLISH] Preparing to publish to ${this.registryQueue} (heartbeat)`);
+    const queueOptions = getQueueOptions(this.registryQueue);
+    
     // Use checkQueue to avoid 406 PRECONDITION-FAILED closing the channel
     try {
       await this.queueManager.channel.checkQueue(this.registryQueue);
+      console.log(`[RegistryClient] [PUBLISH] ✓ Queue ${this.registryQueue} exists`);
     } catch (checkErr) {
       if (checkErr.code === 404) {
-        await this.queueManager.channel.assertQueue(this.registryQueue, { durable: true });
+        console.log(`[RegistryClient] [PUBLISH] Queue ${this.registryQueue} does not exist (404), creating with options:`, JSON.stringify(queueOptions));
+        await this.queueManager.channel.assertQueue(this.registryQueue, queueOptions);
+        console.log(`[RegistryClient] [PUBLISH] ✓ Created queue ${this.registryQueue}`);
+      } else {
+        console.warn(`[RegistryClient] [PUBLISH] Queue ${this.registryQueue} exists with different arguments:`, checkErr.message);
       }
     }
     this.queueManager.channel.sendToQueue(
@@ -412,12 +505,21 @@ class ServiceRegistryClient extends EventEmitter {
       description: apiDescription,
       timestamp: new Date().toISOString()
     };
+    // CRITICAL: Use queueConfig.js to get correct parameters (TTL, max-length, etc.)
+    console.log(`[RegistryClient] [PUBLISH] Preparing to publish to ${this.registryQueue} (apiDescription)`);
+    const queueOptions = getQueueOptions(this.registryQueue);
+    
     // Use checkQueue to avoid 406 PRECONDITION-FAILED closing the channel
     try {
       await this.queueManager.channel.checkQueue(this.registryQueue);
+      console.log(`[RegistryClient] [PUBLISH] ✓ Queue ${this.registryQueue} exists`);
     } catch (checkErr) {
       if (checkErr.code === 404) {
-        await this.queueManager.channel.assertQueue(this.registryQueue, { durable: true });
+        console.log(`[RegistryClient] [PUBLISH] Queue ${this.registryQueue} does not exist (404), creating with options:`, JSON.stringify(queueOptions));
+        await this.queueManager.channel.assertQueue(this.registryQueue, queueOptions);
+        console.log(`[RegistryClient] [PUBLISH] ✓ Created queue ${this.registryQueue}`);
+      } else {
+        console.warn(`[RegistryClient] [PUBLISH] Queue ${this.registryQueue} exists with different arguments:`, checkErr.message);
       }
     }
     this.queueManager.channel.sendToQueue(