@onlineapps/conn-orch-registry 1.1.23 → 1.1.24

package/README.md

@@ -8,7 +8,7 @@
 
 ## 🚀 Features
 
-* Automatic queue management (`workflow`, `<serviceName>.registry`, `api_services_queuer`, `registry_office`)
+* Automatic queue management (`workflow`, `<serviceName>.registry`, `api_services_queuer`, `registry.register`)
 * Periodic heartbeat messages with metadata
 * API description request/response flow
 * Event-driven API using `EventEmitter`
@@ -64,7 +64,7 @@ Configuration can be provided via environment variables or constructor options:
 | `SERVICE_VERSION`    | Service version in SemVer format (required)   | —                    |
 | `HEARTBEAT_INTERVAL` | Interval in ms between heartbeats             | `10000`              |
 | `API_QUEUE`          | Queue name for heartbeat/API messages         | `api_services_queuer` |
-| `REGISTRY_QUEUE`     | Queue name for registry requests/descriptions | `registry_office`    |
+| `REGISTRY_QUEUE`     | Queue name for registry requests/descriptions | `registry.register`  |
 
 ## 📨 Message Formats
 

package/docs/REGISTRY_CLIENT_GUIDE.md

@@ -124,7 +124,7 @@ async function shutdown() {
 | `specificationEndpoint` | string | '/api/v1/specification' | Endpoint for API spec |
 | `heartbeatInterval` | number | 10000 | Heartbeat interval in ms |
 | `apiQueue` | string | 'api_services_queuer' | Queue for API traffic |
-| `registryQueue` | string | 'registry_office' | Registry queue name |
+| `registryQueue` | string | 'registry.register' | Registry queue name |
 
 ### Methods
 

package/package.json

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

@@ -41,12 +41,44 @@ class QueueManager {
   /**
    * Initializes the connection and channel to RabbitMQ.
    * @returns {Promise<void>} 
+   * @throws {Error} If connection or channel creation fails or times out
    */
   async init() {
-    this.conn = await amqp.connect(this.amqpUrl);
+    const CONNECT_TIMEOUT = 10000; // 10 seconds
+    const connectPromise = amqp.connect(this.amqpUrl);
+    const connectTimeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`RabbitMQ connection timeout after ${CONNECT_TIMEOUT}ms. RabbitMQ may be unavailable at ${this.amqpUrl}`));
+      }, CONNECT_TIMEOUT);
+    });
+
+    try {
+      this.conn = await Promise.race([connectPromise, connectTimeoutPromise]);
+    } catch (error) {
+      throw new Error(`[QueueManager] Failed to connect to RabbitMQ: ${error.message}`);
+    }
+
     // Use regular channel instead of ConfirmChannel to avoid RPC reply queue issues
     // ConfirmChannel uses RPC pattern which requires reply queues that may not exist
-    this.channel = await this.conn.createChannel();
+    const CHANNEL_TIMEOUT = 5000; // 5 seconds
+    const channelPromise = this.conn.createChannel();
+    const channelTimeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`Channel creation timeout after ${CHANNEL_TIMEOUT}ms`));
+      }, CHANNEL_TIMEOUT);
+    });
+
+    try {
+      this.channel = await Promise.race([channelPromise, channelTimeoutPromise]);
+    } catch (error) {
+      // Clean up connection on channel creation failure
+      try {
+        await this.conn.close();
+      } catch (closeErr) {
+        // Ignore close errors
+      }
+      throw new Error(`[QueueManager] Failed to create channel: ${error.message}`);
+    }
   }
 
   /**
@@ -70,19 +102,20 @@ class QueueManager {
       // 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 };
+      const isInfrastructureQueue = queueConfig?.isInfrastructureQueue
+        ? queueConfig.isInfrastructureQueue(q)
+        : ['workflow.', 'registry.', 'infrastructure.', 'validation.', 'monitoring.', 'delivery.'].some(prefix => q.startsWith(prefix));
+
+      if (isInfrastructureQueue) {
+        const message = `[QueueManager] [REGISTRY] Refusing to assert infrastructure queue '${q}'. ` +
+          'These queues are owned by infrastructure services and must be created before business services start.';
+        console.error(message);
+        throw new Error(message);
+      }
       
       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`);
-          }
+          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);
         }
@@ -93,13 +126,22 @@ class QueueManager {
       // Directly assert queue with canonical configuration (idempotent)
       try {
         const assertStartTime = Date.now();
-        await this.channel.assertQueue(q, queueOptions);
+        const ASSERT_TIMEOUT = 5000; // 5 seconds
+        const assertPromise = this.channel.assertQueue(q, queueOptions);
+        const assertTimeoutPromise = new Promise((_, reject) => {
+          setTimeout(() => {
+            reject(new Error(`assertQueue timeout after ${ASSERT_TIMEOUT}ms`));
+          }, ASSERT_TIMEOUT);
+        });
+        
+        await Promise.race([assertPromise, assertTimeoutPromise]);
         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;
+        const errorMsg = assertErr.message || String(assertErr);
+        console.error(`[QueueManager] [REGISTRY] [QUEUE] ✗ Failed to assert queue ${q}: ${errorMsg}`);
+        console.error(`[QueueManager] [REGISTRY] [QUEUE] Error code: ${assertErr.code || 'N/A'}`);
+        throw new Error(`[QueueManager] Failed to assert queue ${q}: ${errorMsg}`);
       }
     }
   }

package/src/registryClient.js

@@ -92,7 +92,8 @@ class ServiceRegistryClient extends EventEmitter {
     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(
+    const CONSUME_TIMEOUT = 5000; // 5 seconds
+    const consumeResponsePromise = this.queueManager.channel.consume(
       this.serviceResponseQueue,
       msg => {
         // Handle null message (queue deleted, connection closed, consumer canceled)
@@ -100,17 +101,38 @@ class ServiceRegistryClient extends EventEmitter {
           console.warn(`[RegistryClient] ${this.serviceName}: Received null message from ${this.serviceResponseQueue} (queue may be deleted or connection closed)`);
           return;
         }
-        this._handleRegistryMessage(msg);
+        try {
+          this._handleRegistryMessage(msg);
+        } catch (error) {
+          console.error(`[RegistryClient] ${this.serviceName}: Error in consume callback:`, error);
+          // Nack message on error
+          try {
+            this.queueManager.channel.nack(msg, false, false);
+          } catch (nackErr) {
+            console.error(`[RegistryClient] ${this.serviceName}: Failed to nack message:`, nackErr);
+          }
+        }
       },
       { noAck: false }
     );
+    const consumeResponseTimeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`consume() timeout for ${this.serviceResponseQueue} after ${CONSUME_TIMEOUT}ms`));
+      }, CONSUME_TIMEOUT);
+    });
+
+    try {
+      await Promise.race([consumeResponsePromise, consumeResponseTimeoutPromise]);
+    } catch (consumeErr) {
+      throw new Error(`[RegistryClient] ${this.serviceName}: Failed to start consumer on ${this.serviceResponseQueue}: ${consumeErr.message}`);
+    }
 
     // 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(
+    const consumeRegistryPromise = this.queueManager.channel.consume(
       this.serviceRegistryQueue,
       msg => {
         // Handle null message (queue deleted, connection closed, consumer canceled)
@@ -118,10 +140,31 @@ class ServiceRegistryClient extends EventEmitter {
           console.warn(`[RegistryClient] ${this.serviceName}: Received null message from ${this.serviceRegistryQueue} (queue may be deleted or connection closed)`);
           return;
         }
-        this._handleRegistryMessage(msg);
+        try {
+          this._handleRegistryMessage(msg);
+        } catch (error) {
+          console.error(`[RegistryClient] ${this.serviceName}: Error in consume callback:`, error);
+          // Nack message on error
+          try {
+            this.queueManager.channel.nack(msg, false, false);
+          } catch (nackErr) {
+            console.error(`[RegistryClient] ${this.serviceName}: Failed to nack message:`, nackErr);
+          }
+        }
       },
       { noAck: false }
     );
+    const consumeRegistryTimeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`consume() timeout for ${this.serviceRegistryQueue} after ${CONSUME_TIMEOUT}ms`));
+      }, CONSUME_TIMEOUT);
+    });
+
+    try {
+      await Promise.race([consumeRegistryPromise, consumeRegistryTimeoutPromise]);
+    } catch (consumeErr) {
+      throw new Error(`[RegistryClient] ${this.serviceName}: Failed to start consumer on ${this.serviceRegistryQueue}: ${consumeErr.message}`);
+    }
   }
 
   /**
@@ -138,10 +181,16 @@ class ServiceRegistryClient extends EventEmitter {
       return; // Don't try to parse or ack null message
     }
     
+    // Log which queue this message came from (if available in msg properties)
+    const queueName = msg.fields?.routingKey || msg.fields?.exchange || 'unknown';
+    console.log(`[RegistryClient] ${this.serviceName}: [MESSAGE] Processing message from queue: ${queueName}`);
+    
     let payload;
     try {
       payload = JSON.parse(msg.content.toString());
+      console.log(`[RegistryClient] ${this.serviceName}: [MESSAGE] Parsed payload type: ${payload.type}, requestId: ${payload.requestId}`);
     } catch (err) {
+      console.error(`[RegistryClient] ${this.serviceName}: [MESSAGE] Failed to parse message:`, err);
       this.emit('error', err);
       // Only nack if message is not null
       if (msg) {
@@ -165,22 +214,34 @@ class ServiceRegistryClient extends EventEmitter {
     // Handle registration response from registry
     // Registry sends 'register.confirmed' after validation
     if ((payload.type === 'registerResponse' || payload.type === 'register.confirmed') && payload.requestId) {
-      console.log(`[RegistryClient] ${this.serviceName}: Received ${payload.type} message`, {
+      console.log(`[RegistryClient] ${this.serviceName}: [REGISTRATION] Received ${payload.type} message`, {
         requestId: payload.requestId,
         hasPendingRegistrations: !!(this.pendingRegistrations),
         pendingCount: this.pendingRegistrations ? this.pendingRegistrations.size : 0,
         hasMatchingRequest: !!(this.pendingRegistrations && this.pendingRegistrations.has(payload.requestId)),
-        pendingKeys: this.pendingRegistrations ? Array.from(this.pendingRegistrations.keys()) : []
+        pendingKeys: this.pendingRegistrations ? Array.from(this.pendingRegistrations.keys()) : [],
+        queueName
       });
 
       if (this.pendingRegistrations && this.pendingRegistrations.has(payload.requestId)) {
+        console.log(`[RegistryClient] ${this.serviceName}: [REGISTRATION] Found matching pending registration, extracting resolve function...`);
         const { resolve } = this.pendingRegistrations.get(payload.requestId);
         this.pendingRegistrations.delete(payload.requestId);
-
-        console.log(`[RegistryClient] ${this.serviceName}: ✓ Resolving registration promise for requestId: ${payload.requestId}`);
+        console.log(`[RegistryClient] ${this.serviceName}: [REGISTRATION] ✓ Resolve function extracted, pending registration removed`);
+
+        // CRITICAL: Resolve promise synchronously to ensure it's called before any async operations
+        console.log(`[RegistryClient] ${this.serviceName}: [RESOLVE] Starting resolve process for requestId: ${payload.requestId}`);
+        console.log(`[RegistryClient] ${this.serviceName}: [RESOLVE] Payload keys:`, Object.keys(payload));
+        console.log(`[RegistryClient] ${this.serviceName}: [RESOLVE] Payload.success:`, payload.success);
+        console.log(`[RegistryClient] ${this.serviceName}: [RESOLVE] Payload.validated:`, payload.validated);
+        console.log(`[RegistryClient] ${this.serviceName}: [RESOLVE] Payload.hasCertificate:`, !!payload.certificate);
+        if (payload.certificate) {
+          console.log(`[RegistryClient] ${this.serviceName}: [RESOLVE] Payload.certificate.id:`, payload.certificate.id);
+          console.log(`[RegistryClient] ${this.serviceName}: [RESOLVE] Payload.certificate.serviceName:`, payload.certificate.serviceName);
+        }
 
         // Resolve the registration promise with the response
-        resolve({
+        const registrationResult = {
           success: payload.success || false,
           message: payload.message || 'Registration processed',
           serviceName: this.serviceName,
@@ -188,7 +249,31 @@ class ServiceRegistryClient extends EventEmitter {
           registrationId: payload.registrationId,
           validated: payload.validated || payload.success, // Consider successful registration as validated
           certificate: payload.certificate || null // Include certificate from Registry
-        });
+        };
+        
+        console.log(`[RegistryClient] ${this.serviceName}: [RESOLVE] Created registrationResult:`, JSON.stringify({
+          success: registrationResult.success,
+          validated: registrationResult.validated,
+          hasCertificate: !!registrationResult.certificate,
+          certificateId: registrationResult.certificate?.id || 'none',
+          serviceName: registrationResult.serviceName,
+          version: registrationResult.version
+        }));
+        
+        console.log(`[RegistryClient] ${this.serviceName}: [RESOLVE] About to call resolve() function...`);
+        console.log(`[RegistryClient] ${this.serviceName}: [RESOLVE] resolve function type:`, typeof resolve);
+        console.log(`[RegistryClient] ${this.serviceName}: [RESOLVE] resolve function exists:`, !!resolve);
+        
+        try {
+          // CRITICAL: Call resolve synchronously - this must happen immediately
+          resolve(registrationResult);
+          console.log(`[RegistryClient] ${this.serviceName}: [RESOLVE] ✓ resolve() called successfully`);
+          console.log(`[RegistryClient] ${this.serviceName}: [RESOLVE] Promise should now be resolved`);
+        } catch (resolveError) {
+          console.error(`[RegistryClient] ${this.serviceName}: [RESOLVE] ✗ Error calling resolve():`, resolveError);
+          console.error(`[RegistryClient] ${this.serviceName}: [RESOLVE] Error stack:`, resolveError.stack);
+          throw resolveError;
+        }
       } else {
         console.warn(`[RegistryClient] ${this.serviceName}: ⚠️  Received ${payload.type} with requestId ${payload.requestId}, but no matching pending registration found`);
       }
@@ -225,25 +310,42 @@ class ServiceRegistryClient extends EventEmitter {
     }
 
     if (!this.queueManager?.conn) {
-      console.warn(`[RegistryClient] ${this.serviceName}: MQ connection not ready, cannot verify infrastructure queue ${queueName}`);
-      return;
+      throw new Error(`[RegistryClient] ${this.serviceName}: MQ connection not ready, cannot verify infrastructure queue ${queueName}. Ensure RabbitMQ is accessible.`);
     }
 
-    const verificationChannel = await this.queueManager.conn.createChannel();
+    // Add timeout to prevent hanging
+    const QUEUE_VERIFY_TIMEOUT = 10000; // 10 seconds
+    const verifyPromise = (async () => {
+      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);
+        }
+      }
+    })();
+
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`[RegistryClient] ${this.serviceName}: Timeout verifying infrastructure queue '${queueName}' after ${QUEUE_VERIFY_TIMEOUT}ms. Queue may not exist or RabbitMQ is unresponsive.`));
+      }, QUEUE_VERIFY_TIMEOUT);
+    });
+
     try {
-      await verificationChannel.checkQueue(queueName);
-      this._verifiedInfraQueues.add(queueName);
+      await Promise.race([verifyPromise, timeoutPromise]);
     } catch (error) {
-      if (error.code === 404) {
-        throw new Error(`[RegistryClient] Infrastructure queue '${queueName}' is missing. Ensure the responsible infrastructure service has initialized it.`);
-      }
+      // Clear verification cache on error so we can retry
+      this._verifiedInfraQueues.delete(queueName);
       throw error;
-    } finally {
-      try {
-        await verificationChannel.close();
-      } catch (closeErr) {
-        console.warn(`[RegistryClient] ${this.serviceName}: Failed to close verification channel for ${queueName}:`, closeErr.message);
-      }
     }
   }
 
@@ -323,21 +425,57 @@ class ServiceRegistryClient extends EventEmitter {
     // 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);
+    
+    try {
+      await this._ensureInfrastructureQueue(this.registryQueue);
+    } catch (queueError) {
+      const errorMsg = `[RegistryClient] ${this.serviceName}: Cannot register - infrastructure queue verification failed: ${queueError.message}`;
+      console.error(errorMsg);
+      throw new Error(errorMsg);
+    }
+
     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(
-      this.registryQueue,
-      Buffer.from(JSON.stringify(msg)),
-      { persistent: true }
-    );
-    console.log(`[RegistryClient] ${this.serviceName}: ✓ Registration message sent, waiting for response...`);
+    
+    // Send message synchronously (sendToQueue is synchronous, returns boolean)
+    // But check channel state first to fail fast
+    if (!this.queueManager.channel) {
+      throw new Error(`[RegistryClient] ${this.serviceName}: Cannot publish - channel not initialized. Ensure MQ connection is established.`);
+    }
+    
+    if (this.queueManager.channel.closed) {
+      throw new Error(`[RegistryClient] ${this.serviceName}: Cannot publish - channel is closed. MQ connection may be lost.`);
+    }
+
+    try {
+      const sent = this.queueManager.channel.sendToQueue(
+        this.registryQueue,
+        Buffer.from(JSON.stringify(msg)),
+        { persistent: true }
+      );
+      if (!sent) {
+        throw new Error(`[RegistryClient] ${this.serviceName}: sendToQueue returned false - queue may be full or channel backpressure active.`);
+      }
+      console.log(`[RegistryClient] ${this.serviceName}: ✓ Registration message sent, waiting for response...`);
+    } catch (sendError) {
+      const errorMsg = `[RegistryClient] ${this.serviceName}: Failed to send registration message: ${sendError.message}`;
+      console.error(errorMsg);
+      throw new Error(errorMsg);
+    }
 
     this.emit('registerSent', msg);
 
     // Wait for registration response from registry
     try {
+      console.log(`[RegistryClient] ${this.serviceName}: [AWAIT] Waiting for registration response promise...`);
       const response = await responsePromise;
+      console.log(`[RegistryClient] ${this.serviceName}: [AWAIT] ✓ Promise resolved, response received:`, {
+        hasResponse: !!response,
+        responseType: typeof response,
+        responseKeys: response ? Object.keys(response) : [],
+        hasSuccess: !!response?.success,
+        hasCertificate: !!response?.certificate
+      });
       return response;
     } catch (error) {
       return {