@onlineapps/infrastructure-tools 1.0.28 → 1.0.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/infrastructure-tools",
-  "version": "1.0.28",
+  "version": "1.0.30",
   "description": "Infrastructure orchestration utilities for OA Drive infrastructure services (health tracking, queue initialization, service discovery)",
   "main": "src/index.js",
   "scripts": {

package/src/orchestration/initInfrastructureQueues.js

@@ -108,98 +108,11 @@ async function initInfrastructureQueues(channel, options = {}) {
         throw configError;
       }
       
-      // CRITICAL: First check if queue exists and what parameters it has
-      // This prevents 406 errors by proactively deleting queues with wrong parameters
-      // Use a separate channel for checkQueue to avoid channel closure issues
-      // NOTE: checkQueue() does NOT create queue - it only checks if it exists
-      let queueExists = false;
-      let queueNeedsRecreation = false;
-      let checkChannelForDelete = null;
-      
-      try {
-        // Use a separate channel for checking queue (to avoid closing workingChannel)
-        // CRITICAL: checkQueue() does NOT create queue - it only checks existence
-        checkChannelForDelete = await connection.createChannel();
-        const queueInfo = await checkChannelForDelete.checkQueue(queueName);
-        queueExists = true;
-        
-        // Check if queue has correct arguments
-        const currentArgs = queueInfo.arguments || {};
-        const expectedArgs = config.arguments || {};
-        
-        // Compare arguments (TTL, max-length, etc.)
-        const argsMatch = Object.keys(expectedArgs).every(key => {
-          return currentArgs[key] === expectedArgs[key];
-        }) && Object.keys(currentArgs).every(key => {
-          // Allow extra args in current queue, but required args must match
-          return expectedArgs[key] === undefined || currentArgs[key] === expectedArgs[key];
-        });
-        
-        if (!argsMatch) {
-          logger.warn(`[QueueInit] ⚠ Queue ${queueName} exists with different arguments - will delete and recreate`, {
-            current: currentArgs,
-            expected: expectedArgs
-          });
-          queueNeedsRecreation = true;
-        } else {
-          logger.log(`[QueueInit] ✓ Queue ${queueName} exists with correct parameters`);
-          // Close check channel if queue is OK
-          try {
-            await checkChannelForDelete.close();
-            checkChannelForDelete = null;
-          } catch (closeErr) {
-            // Ignore
-          }
-        }
-      } catch (checkError) {
-        // Queue doesn't exist - will be created
-        queueExists = false;
-        logger.log(`[QueueInit] Queue ${queueName} does not exist (${checkError.code || checkError.message}) - will be created`);
-        // Close check channel if queue doesn't exist
-        if (checkChannelForDelete) {
-          try {
-            await checkChannelForDelete.close();
-            checkChannelForDelete = null;
-          } catch (closeErr) {
-            // Ignore
-          }
-        }
-      }
-      
-      // CRITICAL: If queue exists with wrong parameters, delete it first
-      // This must be done BEFORE assertQueue to avoid 406 errors
-      if (queueNeedsRecreation) {
-        try {
-          // Use the check channel for deletion (or create new one if check failed)
-          const deleteChannel = checkChannelForDelete || await connection.createChannel();
-          await deleteChannel.deleteQueue(queueName, { ifEmpty: false });
-          logger.log(`[QueueInit] ✓ Deleted queue ${queueName} with incorrect parameters`);
-          // Close delete channel after use
-          try {
-            await deleteChannel.close();
-          } catch (closeErr) {
-            // Ignore close errors
-          }
-          checkChannelForDelete = null;
-          
-          // Wait to ensure deletion is processed and no frames are pending
-          await new Promise(resolve => setTimeout(resolve, 300));
-          queueExists = false; // Queue no longer exists, will be created
-        } catch (deleteError) {
-          logger.error(`[QueueInit] ✗ Failed to delete queue ${queueName}:`, deleteError.message);
-          // Clean up check channel if still open
-          if (checkChannelForDelete) {
-            try {
-              await checkChannelForDelete.close();
-            } catch (closeErr) {
-              // Ignore
-            }
-          }
-          throw new Error(`Cannot delete queue ${queueName} with incorrect parameters: ${deleteError.message}`);
-        }
-      }
-      
-      // CRITICAL: Now create/verify queue with correct parameters
+      // CRITICAL: Create/verify queue directly with assertQueue
+      // NOTE: We do NOT use checkQueue first because:
+      // - checkQueue throws 404 if queue doesn't exist, which closes the channel
+      // - assertQueue creates queue if it doesn't exist, OR verifies params if it does
+      // - If params mismatch, we get 406 PRECONDITION-FAILED which we handle below
       const ensureQueue = async () => {
         const activeChannel = await getChannel();
         return activeChannel.assertQueue(queueName, {
@@ -213,13 +126,15 @@ async function initInfrastructureQueues(channel, options = {}) {
         await ensureQueue();
         logger.log(`[QueueInit] ✓ Created/verified infrastructure queue: ${queueName}`);
       } catch (assertError) {
-        logger.error(`[QueueInit] ✗ Failed to create/verify queue ${queueName}:`, {
+        logger.error(`[QueueInit] ✗ assertQueue failed for ${queueName}:`, {
           error: assertError.message,
           code: assertError.code,
           classId: assertError.classId,
           methodId: assertError.methodId
         });
+        
         if (assertError.code === 406) {
+          // 406 PRECONDITION-FAILED: queue exists with different parameters
           if (alertOnMismatch) {
             try {
               await sendQueueMismatchAlert({
@@ -234,12 +149,11 @@ async function initInfrastructureQueues(channel, options = {}) {
               logger.warn('[QueueInit] Failed to send queue mismatch alert', alertError.message);
             }
           }
-          logger.warn(
-            `[QueueInit] ⚠ Queue ${queueName} exists with different arguments - deleting and recreating...`
-          );
+          
+          logger.warn(`[QueueInit] ⚠ Queue ${queueName} exists with different arguments - deleting and recreating...`);
+          
           try {
-            // CRITICAL: Use a fresh channel for delete operation to avoid closed channel errors
-            // Close the current channel first to prevent it from receiving frames during deletion
+            // Close the current channel first (it's likely closed from 406 error anyway)
             if (workingChannel && !workingChannel.__queueInitClosed) {
               try {
                 await workingChannel.close();
@@ -249,27 +163,23 @@ async function initInfrastructureQueues(channel, options = {}) {
               }
             }
             
+            // Delete queue with fresh channel
             const deleteChannel = await getChannel(true);
             await deleteChannel.deleteQueue(queueName, { ifEmpty: false });
             logger.log(`[QueueInit] ✓ Deleted queue ${queueName} with incorrect parameters`);
-            // Close delete channel after use to avoid channel leaks
+            
+            // Close delete channel
             try {
               await deleteChannel.close();
             } catch (closeErr) {
-              // Ignore close errors - channel may already be closed
+              // Ignore close errors
             }
           } catch (deleteError) {
-            logger.error(
-              `[QueueInit] ✗ Failed to delete queue ${queueName}:`,
-              deleteError.message
-            );
-            throw new Error(
-              `Cannot delete queue ${queueName} with incorrect parameters: ${deleteError.message}`
-            );
+            logger.error(`[QueueInit] ✗ Failed to delete queue ${queueName}:`, deleteError.message);
+            throw new Error(`Cannot delete queue ${queueName} with incorrect parameters: ${deleteError.message}`);
           }
 
-          // CRITICAL: Recreate with correct parameters using a fresh channel
-          // Wait a brief moment to ensure queue deletion is fully processed and no frames are pending
+          // Recreate with correct parameters using a fresh channel
           await new Promise(resolve => setTimeout(resolve, 200));
           const recreateChannel = await getChannel(true);
           try {
@@ -277,17 +187,14 @@ async function initInfrastructureQueues(channel, options = {}) {
               durable: config.durable !== false,
               arguments: { ...config.arguments }
             });
-            logger.log(
-              `[QueueInit] ✓ Recreated infrastructure queue: ${queueName} with correct parameters`
-            );
-            // Update workingChannel to the new channel for subsequent operations
+            logger.log(`[QueueInit] ✓ Recreated infrastructure queue: ${queueName} with correct parameters`);
             workingChannel = recreateChannel;
           } catch (recreateError) {
             logger.error(`[QueueInit] ✗ Failed to recreate ${queueName}:`, recreateError.message);
             throw recreateError;
           }
         } else {
-          logger.error(`[QueueInit] ✗ Failed to create ${queueName}:`, assertError.message);
+          // Other error - rethrow
           throw assertError;
         }
       }
@@ -303,4 +210,3 @@ async function initInfrastructureQueues(channel, options = {}) {
 module.exports = {
   initInfrastructureQueues
 };
-