npm - @azteam/rabbitmq-async - Versions diffs - 1.0.166 → 1.0.167 - Mend

@azteam/rabbitmq-async 1.0.166 → 1.0.167

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/lib/RabbitMQAsync.js CHANGED Viewed

@@ -390,60 +390,81 @@ var RabbitMQAsync = /*#__PURE__*/function () {
       }
       return getInfo;
     }()
+  }, {
+    key: "getSelfInfo",
+    value: function () {
+      var _getSelfInfo = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9(queueName) {
+        return _regeneratorRuntime().wrap(function _callee9$(_context9) {
+          while (1) {
+            switch (_context9.prev = _context9.next) {
+              case 0:
+                return _context9.abrupt("return", this.getInfo("".concat(this.serverIp, "_").concat(queueName)));
+              case 1:
+              case "end":
+                return _context9.stop();
+            }
+          }
+        }, _callee9, this);
+      }));
+      function getSelfInfo(_x6) {
+        return _getSelfInfo.apply(this, arguments);
+      }
+      return getSelfInfo;
+    }()
   }, {
     key: "consume",
     value: function () {
-      var _consume = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10(queueName, cb) {
+      var _consume = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11(queueName, cb) {
         var callbackError,
           prefixQueueName,
           channel,
           messageQueue,
-          _args10 = arguments;
-        return _regeneratorRuntime().wrap(function _callee10$(_context10) {
+          _args11 = arguments;
+        return _regeneratorRuntime().wrap(function _callee11$(_context11) {
           while (1) {
-            switch (_context10.prev = _context10.next) {
+            switch (_context11.prev = _context11.next) {
               case 0:
-                callbackError = _args10.length > 2 && _args10[2] !== undefined ? _args10[2] : null;
+                callbackError = _args11.length > 2 && _args11[2] !== undefined ? _args11[2] : null;
                 prefixQueueName = this.parsePrefix(queueName);
                 if (!this.connected) {
-                  _context10.next = 30;
+                  _context11.next = 30;
                   break;
                 }
-                _context10.prev = 3;
-                _context10.next = 6;
+                _context11.prev = 3;
+                _context11.next = 6;
                 return this.client.createChannel();
               case 6:
-                channel = _context10.sent;
-                _context10.next = 9;
+                channel = _context11.sent;
+                _context11.next = 9;
                 return channel.assertQueue(prefixQueueName, {
                   durable: true
                 });
               case 9:
-                _context10.next = 11;
+                _context11.next = 11;
                 return channel.prefetch(1);
               case 11:
                 messageQueue = this;
-                _context10.next = 14;
+                _context11.next = 14;
                 return new Promise(function (resolve, reject) {
                   channel.consume(prefixQueueName, /*#__PURE__*/function () {
-                    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9(msg) {
+                    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10(msg) {
                       var data, errString;
-                      return _regeneratorRuntime().wrap(function _callee9$(_context9) {
+                      return _regeneratorRuntime().wrap(function _callee10$(_context10) {
                         while (1) {
-                          switch (_context9.prev = _context9.next) {
+                          switch (_context10.prev = _context10.next) {
                             case 0:
                               if (!msg) {
-                                _context9.next = 55;
+                                _context10.next = 55;
                                 break;
                               }
                               data = JSON.parse(msg.content.toString());
                               if (!data) {
-                                _context9.next = 52;
+                                _context10.next = 52;
                                 break;
                               }
-                              _context9.prev = 3;
+                              _context10.prev = 3;
                               if (!msg.fields.redelivered) {
-                                _context9.next = 23;
+                                _context10.next = 23;
                                 break;
                               }
                               if (!data.retry) {
@@ -451,143 +472,143 @@ var RabbitMQAsync = /*#__PURE__*/function () {
                               }
                               data.retry += 1;
                               if (!(data.retry < 5)) {
-                                _context9.next = 17;
+                                _context10.next = 17;
                                 break;
                               }
                               if (!(messageQueue.worker && !queueName.startsWith(messageQueue.serverIp))) {
-                                _context9.next = 13;
+                                _context10.next = 13;
                                 break;
                               }
-                              _context9.next = 11;
+                              _context10.next = 11;
                               return messageQueue.send("".concat(messageQueue.serverIp, "_").concat(queueName), data);
                             case 11:
-                              _context9.next = 15;
+                              _context10.next = 15;
                               break;
                             case 13:
-                              _context9.next = 15;
+                              _context10.next = 15;
                               return messageQueue.send(queueName, data);
                             case 15:
-                              _context9.next = 19;
+                              _context10.next = 19;
                               break;
                             case 17:
-                              _context9.next = 19;
+                              _context10.next = 19;
                               return messageQueue.send(messageQueue.parsePrefix('RETRY'), {
                                 queueName: queueName,
                                 data: data,
                                 retry_time: new Date()
                               });
                             case 19:
-                              _context9.next = 21;
+                              _context10.next = 21;
                               return channel.ack(msg);
                             case 21:
-                              _context9.next = 45;
+                              _context10.next = 45;
                               break;
                             case 23:
-                              _context9.prev = 23;
-                              _context9.next = 26;
+                              _context10.prev = 23;
+                              _context10.next = 26;
                               return cb(data);
                             case 26:
-                              _context9.next = 28;
+                              _context10.next = 28;
                               return channel.ack(msg);
                             case 28:
-                              _context9.next = 45;
+                              _context10.next = 45;
                               break;
                             case 30:
-                              _context9.prev = 30;
-                              _context9.t0 = _context9["catch"](23);
-                              errString = _context9.t0.toString();
+                              _context10.prev = 30;
+                              _context10.t0 = _context10["catch"](23);
+                              errString = _context10.t0.toString();
                               if (!_lodash["default"].some(['IllegalOperationError: Channel closed'], function (el) {
                                 return _lodash["default"].includes(errString, el);
                               })) {
-                                _context9.next = 37;
+                                _context10.next = 37;
                                 break;
                               }
                               reject(new Error(errString));
-                              _context9.next = 45;
+                              _context10.next = 45;
                               break;
                             case 37:
                               if (callbackError) {
-                                callbackError(prefixQueueName, _context9.t0);
+                                callbackError(prefixQueueName, _context10.t0);
                               }
                               if (!data.noRetry) {
-                                _context9.next = 43;
+                                _context10.next = 43;
                                 break;
                               }
-                              _context9.next = 41;
+                              _context10.next = 41;
                               return channel.ack(msg);
                             case 41:
-                              _context9.next = 45;
+                              _context10.next = 45;
                               break;
                             case 43:
-                              _context9.next = 45;
+                              _context10.next = 45;
                               return channel.nack(msg);
                             case 45:
-                              _context9.next = 50;
+                              _context10.next = 50;
                               break;
                             case 47:
-                              _context9.prev = 47;
-                              _context9.t1 = _context9["catch"](3);
-                              reject(_context9.t1);
+                              _context10.prev = 47;
+                              _context10.t1 = _context10["catch"](3);
+                              reject(_context10.t1);
                             case 50:
-                              _context9.next = 53;
+                              _context10.next = 53;
                               break;
                             case 52:
                               channel.ack(msg);
                             case 53:
-                              _context9.next = 56;
+                              _context10.next = 56;
                               break;
                             case 55:
                               reject(new Error('msg null'));
                             case 56:
                             case "end":
-                              return _context9.stop();
+                              return _context10.stop();
                           }
                         }
-                      }, _callee9, null, [[3, 47], [23, 30]]);
+                      }, _callee10, null, [[3, 47], [23, 30]]);
                     }));
-                    return function (_x8) {
+                    return function (_x9) {
                       return _ref.apply(this, arguments);
                     };
                   }());
                 });
               case 14:
-                _context10.next = 28;
+                _context11.next = 28;
                 break;
               case 16:
-                _context10.prev = 16;
-                _context10.t0 = _context10["catch"](3);
-                _context10.prev = 18;
-                _context10.next = 21;
+                _context11.prev = 16;
+                _context11.t0 = _context11["catch"](3);
+                _context11.prev = 18;
+                _context11.next = 21;
                 return channel.close();
               case 21:
-                _context10.next = 25;
+                _context11.next = 25;
                 break;
               case 23:
-                _context10.prev = 23;
-                _context10.t1 = _context10["catch"](18);
+                _context11.prev = 23;
+                _context11.t1 = _context11["catch"](18);
               case 25:
-                _context10.next = 27;
+                _context11.next = 27;
                 return (0, _util.timeout)(5000);
               case 27:
-                return _context10.abrupt("return", this.consume(queueName, cb, callbackError));
+                return _context11.abrupt("return", this.consume(queueName, cb, callbackError));
               case 28:
-                _context10.next = 33;
+                _context11.next = 33;
                 break;
               case 30:
-                _context10.next = 32;
+                _context11.next = 32;
                 return (0, _util.timeout)(5000);
               case 32:
-                return _context10.abrupt("return", this.consume(queueName, cb, callbackError));
+                return _context11.abrupt("return", this.consume(queueName, cb, callbackError));
               case 33:
-                return _context10.abrupt("return", true);
+                return _context11.abrupt("return", true);
               case 34:
               case "end":
-                return _context10.stop();
+                return _context11.stop();
             }
           }
-        }, _callee10, this, [[3, 16], [18, 23]]);
+        }, _callee11, this, [[3, 16], [18, 23]]);
       }));
-      function consume(_x6, _x7) {
+      function consume(_x7, _x8) {
         return _consume.apply(this, arguments);
       }
       return consume;
@@ -595,20 +616,20 @@ var RabbitMQAsync = /*#__PURE__*/function () {
   }, {
     key: "selfReceiving",
     value: function () {
-      var _selfReceiving = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11(queueName, cb, callbackError) {
-        return _regeneratorRuntime().wrap(function _callee11$(_context11) {
+      var _selfReceiving = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee12(queueName, cb, callbackError) {
+        return _regeneratorRuntime().wrap(function _callee12$(_context12) {
           while (1) {
-            switch (_context11.prev = _context11.next) {
+            switch (_context12.prev = _context12.next) {
               case 0:
                 this.consume("".concat(this.serverIp, "_").concat(queueName), cb, callbackError);
               case 1:
               case "end":
-                return _context11.stop();
+                return _context12.stop();
             }
           }
-        }, _callee11, this);
+        }, _callee12, this);
       }));
-      function selfReceiving(_x9, _x10, _x11) {
+      function selfReceiving(_x10, _x11, _x12) {
         return _selfReceiving.apply(this, arguments);
       }
       return selfReceiving;
@@ -616,26 +637,26 @@ var RabbitMQAsync = /*#__PURE__*/function () {
   }, {
     key: "receiving",
     value: function () {
-      var _receiving = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee12(queueName, cb) {
+      var _receiving = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee13(queueName, cb) {
         var callbackError,
-          _args12 = arguments;
-        return _regeneratorRuntime().wrap(function _callee12$(_context12) {
+          _args13 = arguments;
+        return _regeneratorRuntime().wrap(function _callee13$(_context13) {
           while (1) {
-            switch (_context12.prev = _context12.next) {
+            switch (_context13.prev = _context13.next) {
               case 0:
-                callbackError = _args12.length > 2 && _args12[2] !== undefined ? _args12[2] : null;
+                callbackError = _args13.length > 2 && _args13[2] !== undefined ? _args13[2] : null;
                 this.consume(queueName, cb, callbackError);
                 if (this.worker) {
                   this.selfReceiving(queueName, cb, callbackError);
                 }
               case 3:
               case "end":
-                return _context12.stop();
+                return _context13.stop();
             }
           }
-        }, _callee12, this);
+        }, _callee13, this);
       }));
-      function receiving(_x12, _x13) {
+      function receiving(_x13, _x14) {
         return _receiving.apply(this, arguments);
       }
       return receiving;

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
     "name": "@azteam/rabbitmq-async",
-    "version": "1.0.166",
+    "version": "1.0.167",
     "description": "",
     "keywords": [
         "toda",

package/src/RabbitMQAsync.js CHANGED Viewed

@@ -138,6 +138,10 @@ class RabbitMQAsync {
         }
     }
+    async getSelfInfo(queueName) {
+        return this.getInfo(`${this.serverIp}_${queueName}`);
+    }
     async consume(queueName, cb, callbackError = null) {
         const prefixQueueName = this.parsePrefix(queueName);