@azteam/rabbitmq-async 1.0.219 → 1.0.220

package/lib/RabbitMQAsync.js

@@ -295,30 +295,30 @@ var RabbitMQAsync = /*#__PURE__*/function () {
     value: function () {
       var _consume = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8(queueName, asyncFunction) {
         var callbackError,
+          messageQueue,
           prefixQueueName,
           channel,
-          messageQueue,
           _args8 = arguments;
         return _regeneratorRuntime().wrap(function _callee8$(_context8) {
           while (1) switch (_context8.prev = _context8.next) {
             case 0:
               callbackError = _args8.length > 2 && _args8[2] !== undefined ? _args8[2] : null;
-              _context8.prev = 1;
+              messageQueue = this;
+              _context8.prev = 2;
               if (!this.connected) {
                 _context8.next = 10;
                 break;
               }
-              prefixQueueName = this.parsePrefix(queueName), channel = this.channel;
+              prefixQueueName = this.parsePrefix(queueName), channel = messageQueue.channel;
               if (!channel) {
                 _context8.next = 10;
                 break;
               }
-              _context8.next = 7;
+              _context8.next = 8;
               return channel.assertQueue(prefixQueueName, {
                 durable: true
               });
-            case 7:
-              messageQueue = this;
+            case 8:
               _context8.next = 10;
               return new Promise(function (resolve, reject) {
                 channel.consume(prefixQueueName, /*#__PURE__*/function () {
@@ -379,7 +379,7 @@ var RabbitMQAsync = /*#__PURE__*/function () {
                           _context7.prev = 24;
                           _context7.t0 = _context7["catch"](17);
                           errString = _context7.t0.toString();
-                          if (!_lodash["default"].some(['IllegalOperationError: Channel closed'], function (el) {
+                          if (!_lodash["default"].some(['Channel closed', 'Channel closing'], function (el) {
                             return _lodash["default"].includes(errString, el);
                           })) {
                             _context7.next = 31;
@@ -428,21 +428,25 @@ var RabbitMQAsync = /*#__PURE__*/function () {
                 }());
               });
             case 10:
-              _context8.next = 17;
+              _context8.next = 18;
               break;
             case 12:
               _context8.prev = 12;
-              _context8.t0 = _context8["catch"](1);
+              _context8.t0 = _context8["catch"](2);
               _context8.next = 16;
               return (0, _util.timeout)(5000);
             case 16:
-              this._alert('error', _context8.t0);
-              // return this.consume(queueName, asyncFunction, callbackError);
-            case 17:
+              this._alert('err3', _context8.t0);
+              if (_lodash["default"].some(['Channel closed'], function (el) {
+                return _lodash["default"].includes(_context8.t0.toString(), el);
+              })) {
+                messageQueue.close();
+              }
+            case 18:
             case "end":
               return _context8.stop();
           }
-        }, _callee8, this, [[1, 12]]);
+        }, _callee8, this, [[2, 12]]);
       }));
       function consume(_x3, _x4) {
         return _consume.apply(this, arguments);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@azteam/rabbitmq-async",
-    "version": "1.0.219",
+    "version": "1.0.220",
     "description": "N/A",
     "keywords": [
         "toda",

package/src/RabbitMQAsync.js

@@ -120,15 +120,15 @@ class RabbitMQAsync {
 
     // eslint-disable-next-line consistent-return
     async consume(queueName, asyncFunction, callbackError = null) {
+        const messageQueue = this;
         try {
             if (this.connected) {
                 const prefixQueueName = this.parsePrefix(queueName),
-                    {channel} = this;
+                    {channel} = messageQueue;
                 if (channel) {
                     await channel.assertQueue(prefixQueueName, {
                         durable: true,
                     });
-                    const messageQueue = this;
                     await new Promise((resolve, reject) => {
                         channel.consume(prefixQueueName, async function (msg) {
                             if (msg) {
@@ -154,7 +154,7 @@ class RabbitMQAsync {
                                                 await channel.ack(msg);
                                             } catch (err1) {
                                                 const errString = err1.toString();
-                                                if (_.some(['IllegalOperationError: Channel closed'], (el) => _.includes(errString, el))) {
+                                                if (_.some(['Channel closed', 'Channel closing'], (el) => _.includes(errString, el))) {
                                                     reject(err1);
                                                 } else {
                                                     if (callbackError && data.retry === 1) {
@@ -181,8 +181,10 @@ class RabbitMQAsync {
             }
         } catch (err3) {
             await timeout(5000);
-            this._alert('error', err3);
-            // return this.consume(queueName, asyncFunction, callbackError);
+            this._alert('err3', err3);
+            if (_.some(['Channel closed'], (el) => _.includes(err3.toString(), el))) {
+                messageQueue.close();
+            }
         }
     }