amqplib 0.10.8 → 1.0.0

package/lib/channel.js

@@ -1,23 +1,15 @@
-//
-//
-//
-
-// Channel machinery.
-
-'use strict';
-
-var defs = require('./defs');
-var closeMsg = require('./format').closeMessage;
-var inspect = require('./format').inspect;
-var methodName = require('./format').methodName;
-var assert = require('assert');
-var EventEmitter = require('events');
-var fmt = require('util').format;
-var IllegalOperationError = require('./error').IllegalOperationError;
-var stackCapture = require('./error').stackCapture;
+const defs = require('./defs');
+const closeMsg = require('./format').closeMessage;
+const inspect = require('./format').inspect;
+const methodName = require('./format').methodName;
+const assert = require('node:assert');
+const EventEmitter = require('node:events');
+const fmt = require('node:util').format;
+const IllegalOperationError = require('./error').IllegalOperationError;
+const stackCapture = require('./error').stackCapture;
 
 class Channel extends EventEmitter {
-  constructor (connection) {
+  constructor(connection) {
     super();
 
     this.connection = connection;
@@ -28,19 +20,23 @@ class Channel extends EventEmitter {
     // for unconfirmed messages
     this.lwm = 1; // the least, unconfirmed deliveryTag
     this.unconfirmed = []; // rolling window of delivery callbacks
-    this.on('ack', this.handleConfirm.bind(this, function (cb) {
-      if (cb)
-        cb(null);
-    }));
-    this.on('nack', this.handleConfirm.bind(this, function (cb) {
-      if (cb)
-        cb(new Error('message nacked'));
-    }));
+    this.on(
+      'ack',
+      this.handleConfirm.bind(this, (cb) => {
+        if (cb) cb(null);
+      }),
+    );
+    this.on(
+      'nack',
+      this.handleConfirm.bind(this, (cb) => {
+        if (cb) cb(new Error('message nacked'));
+      }),
+    );
     this.on('close', function () {
-      var cb;
-      while (cb = this.unconfirmed.shift()) {
-        if (cb)
-          cb(new Error('channel closed'));
+      let cb = this.unconfirmed.shift();
+      while (cb) {
+        if (cb) cb(new Error('channel closed'));
+        cb = this.unconfirmed.shift();
       }
     });
     // message frame state machine
@@ -51,7 +47,7 @@ class Channel extends EventEmitter {
     this.options = options;
   }
 
-  allocate () {
+  allocate() {
     this.ch = this.connection.freshChannel(this, this.options);
     return this;
   }
@@ -67,7 +63,7 @@ class Channel extends EventEmitter {
   // this reason, I buffer RPCs if the channel is already waiting for a
   // reply.
   // Just send the damn frame.
-  sendImmediately (method, fields) {
+  sendImmediately(method, fields) {
     return this.connection.sendMethod(this.ch, method, fields);
   }
 
@@ -75,70 +71,58 @@ class Channel extends EventEmitter {
   // clear a reply, we must send another RPC (and thereby fill
   // this.reply) if there is one waiting. The invariant relevant here
   // and in `accept`.
-  sendOrEnqueue (method, fields, reply) {
-    if (!this.reply) { // if no reply waiting, we can go
+  sendOrEnqueue(method, fields, reply) {
+    if (!this.reply) {
+      // if no reply waiting, we can go
       assert(this.pending.length === 0);
       this.reply = reply;
       this.sendImmediately(method, fields);
-    }
-    else {
+    } else {
       this.pending.push({
         method: method,
         fields: fields,
-        reply: reply
+        reply: reply,
       });
     }
   }
 
-  sendMessage (fields, properties, content) {
-    return this.connection.sendMessage(
-      this.ch,
-      defs.BasicPublish, fields,
-      defs.BasicProperties, properties,
-      content);
+  sendMessage(fields, properties, content) {
+    return this.connection.sendMessage(this.ch, defs.BasicPublish, fields, defs.BasicProperties, properties, content);
   }
 
   // Internal, synchronously resolved RPC; the return value is resolved
   // with the whole frame.
-  _rpc (method, fields, expect, cb) {
-    var self = this;
+  _rpc(method, fields, expect, cb) {
+    const self = this;
 
-    function reply (err, f) {
+    function reply(err, f) {
       if (err === null) {
         if (f.id === expect) {
           return cb(null, f);
-        }
-        else {
+        } else {
           // We have detected a problem, so it's up to us to close the
           // channel
-          var expectedName = methodName(expect);
+          const expectedName = methodName(expect);
 
-          var e = new Error(fmt("Expected %s; got %s",
-            expectedName, inspect(f, false)));
-          self.closeWithError(f.id, fmt('Expected %s; got %s',
-            expectedName, methodName(f.id)),
-            defs.constants.UNEXPECTED_FRAME, e);
+          const e = new Error(fmt('Expected %s; got %s', expectedName, inspect(f, false)));
+          self.closeWithError(f.id, fmt('Expected %s; got %s', expectedName, methodName(f.id)), defs.constants.UNEXPECTED_FRAME, e);
           return cb(e);
         }
       }
 
-
       // An error will be given if, for example, this is waiting to be
       // sent and the connection closes
-      else if (err instanceof Error)
-        return cb(err);
-
-
+      else if (err instanceof Error) return cb(err);
       // A close frame will be given if this is the RPC awaiting reply
       // and the channel is closed by the server
       else {
         // otherwise, it's a close frame
-        var closeReason = (err.fields.classId << 16) + err.fields.methodId;
-        var e = (method === closeReason)
-          ? fmt("Operation failed: %s; %s",
-            methodName(method), closeMsg(err))
-          : fmt("Channel closed by server: %s", closeMsg(err));
-        var closeFrameError = new Error(e);
+        const closeReason = (err.fields.classId << 16) + err.fields.methodId;
+        const e =
+          method === closeReason
+            ? fmt('Operation failed: %s; %s', methodName(method), closeMsg(err))
+            : fmt('Channel closed by server: %s', closeMsg(err));
+        const closeFrameError = new Error(e);
         closeFrameError.code = err.fields.replyCode;
         closeFrameError.classId = err.fields.classId;
         closeFrameError.methodId = err.fields.methodId;
@@ -150,7 +134,7 @@ class Channel extends EventEmitter {
   }
 
   // Move to entirely closed state.
-  toClosed (capturedStack) {
+  toClosed(capturedStack) {
     this._rejectPending();
     invalidateSend(this, 'Channel closed', capturedStack);
     this.accept = invalidOp('Channel closed', capturedStack);
@@ -162,61 +146,60 @@ class Channel extends EventEmitter {
   // we close the channel. Invokes the continuation once the server has
   // acknowledged the close, but before the channel is moved to the
   // closed state.
-  toClosing (capturedStack, k) {
-    var send = this.sendImmediately.bind(this);
+  toClosing(capturedStack, k) {
+    const send = this.sendImmediately.bind(this);
     invalidateSend(this, 'Channel closing', capturedStack);
 
     this.accept = function (f) {
       if (f.id === defs.ChannelCloseOk) {
-        if (k)
-          k();
-        var s = stackCapture('ChannelCloseOk frame received');
+        if (k) k();
+        const s = stackCapture('ChannelCloseOk frame received');
         this.toClosed(s);
-      }
-      else if (f.id === defs.ChannelClose) {
+      } else if (f.id === defs.ChannelClose) {
         send(defs.ChannelCloseOk, {});
       }
       // else ignore frame
     };
   }
 
-  _rejectPending () {
-    function rej (r) {
-      r(new Error("Channel ended, no reply will be forthcoming"));
+  _rejectPending() {
+    function reject(r) {
+      r(new Error('Channel ended, no reply will be forthcoming'));
     }
-    if (this.reply !== null)
-      rej(this.reply);
+    if (this.reply !== null) reject(this.reply);
     this.reply = null;
 
-    var discard;
-    while (discard = this.pending.shift())
-      rej(discard.reply);
+    let discard = this.pending.shift();
+    while (discard) {
+      if (discard) reject(discard.reply);
+      discard = this.pending.shift();
+    }
     this.pending = null; // so pushes will break
   }
 
-  closeBecause (reason, code, k) {
+  closeBecause(reason, code, k) {
     this.sendImmediately(defs.ChannelClose, {
       replyText: reason,
       replyCode: code,
-      methodId: 0, classId: 0
+      methodId: 0,
+      classId: 0,
     });
-    var s = stackCapture('closeBecause called: ' + reason);
+    const s = stackCapture(`closeBecause called: ${reason}`);
     this.toClosing(s, k);
   }
 
   // If we close because there's been an error, we need to distinguish
   // between what we tell the server (`reason`) and what we report as
   // the cause in the client (`error`).
-  closeWithError (id, reason, code, error) {
-    var self = this;
-    this.closeBecause(reason, code, function () {
+  closeWithError(id, reason, code, error) {
+    this.closeBecause(reason, code, () => {
       error.code = code;
       // content frames and consumer errors do not provide a method a class/method ID
       if (id) {
         error.classId = defs.info(id).classId;
         error.methodId = defs.info(id).methodId;
       }
-      self.emit('error', error);
+      this.emit('error', error);
     });
   }
 
@@ -227,38 +210,30 @@ class Channel extends EventEmitter {
   // frames.
   // Keep the try/catch localised, in an attempt to avoid disabling
   // optimisation
-  acceptMessageFrame (f) {
+  acceptMessageFrame(f) {
     try {
       this.handleMessage = this.handleMessage(f);
-    }
-    catch (msg) {
+    } catch (msg) {
       if (typeof msg === 'string') {
-        this.closeWithError(f.id, msg, defs.constants.UNEXPECTED_FRAME,
-          new Error(msg));
-      }
-      else if (msg instanceof Error) {
-        this.closeWithError(f.id, 'Error while processing message',
-          defs.constants.INTERNAL_ERROR, msg);
-      }
-      else {
-        this.closeWithError(f.id, 'Internal error while processing message',
-          defs.constants.INTERNAL_ERROR,
-          new Error(msg.toString()));
+        this.closeWithError(f.id, msg, defs.constants.UNEXPECTED_FRAME, new Error(msg));
+      } else if (msg instanceof Error) {
+        this.closeWithError(f.id, 'Error while processing message', defs.constants.INTERNAL_ERROR, msg);
+      } else {
+        this.closeWithError(f.id, 'Internal error while processing message', defs.constants.INTERNAL_ERROR, new Error(msg.toString()));
       }
     }
   }
 
-  handleConfirm (handle, f) {
-    var tag = f.deliveryTag;
-    var multi = f.multiple;
+  handleConfirm(handle, f) {
+    const tag = f.deliveryTag;
+    const multi = f.multiple;
 
     if (multi) {
-      var confirmed = this.unconfirmed.splice(0, tag - this.lwm + 1);
+      const confirmed = this.unconfirmed.splice(0, tag - this.lwm + 1);
       this.lwm = tag + 1;
       confirmed.forEach(handle);
-    }
-    else {
-      var c;
+    } else {
+      let c;
       if (tag === this.lwm) {
         c = this.unconfirmed.shift();
         this.lwm++;
@@ -268,8 +243,7 @@ class Channel extends EventEmitter {
           this.unconfirmed.shift();
           this.lwm++;
         }
-      }
-      else {
+      } else {
         c = this.unconfirmed[tag - this.lwm];
         this.unconfirmed[tag - this.lwm] = null;
       }
@@ -279,78 +253,79 @@ class Channel extends EventEmitter {
     }
   }
 
-  pushConfirmCallback (cb) {
+  pushConfirmCallback(cb) {
     // `null` is used specifically for marking already confirmed slots,
     // so I coerce `undefined` and `null` to false; functions are never
     // falsey.
     this.unconfirmed.push(cb || false);
   }
 
-  onBufferDrain () {
+  onBufferDrain() {
     this.emit('drain');
   }
 
   accept(f) {
-
     switch (f.id) {
-
       // Message frames
-    case undefined: // content frame!
-    case defs.BasicDeliver:
-    case defs.BasicReturn:
-    case defs.BasicProperties:
-      return this.acceptMessageFrame(f);
+      case undefined: // content frame!
+      case defs.BasicDeliver:
+      case defs.BasicReturn:
+      case defs.BasicProperties:
+        return this.acceptMessageFrame(f);
 
       // confirmations, need to do confirm.select first
-    case defs.BasicAck:
-      return this.emit('ack', f.fields);
-    case defs.BasicNack:
-      return this.emit('nack', f.fields);
-    case defs.BasicCancel:
-      // The broker can send this if e.g., the queue is deleted.
-      return this.emit('cancel', f.fields);
-
-    case defs.ChannelClose:
-      // Any remote closure is an error to us. Reject the pending reply
-      // with the close frame, so it can see whether it was that
-      // operation that caused it to close.
-      if (this.reply) {
-        var reply = this.reply; this.reply = null;
-        reply(f);
-      }
-      var emsg = "Channel closed by server: " + closeMsg(f);
-      this.sendImmediately(defs.ChannelCloseOk, {});
+      case defs.BasicAck:
+        return this.emit('ack', f.fields);
+      case defs.BasicNack:
+        return this.emit('nack', f.fields);
+      case defs.BasicCancel:
+        // The broker can send this if e.g., the queue is deleted.
+        return this.emit('cancel', f.fields);
+
+      case defs.ChannelClose: {
+        // Any remote closure is an error to us. Reject the pending reply
+        // with the close frame, so it can see whether it was that
+        // operation that caused it to close.
+        if (this.reply) {
+          const reply = this.reply;
+          this.reply = null;
+          reply(f);
+        }
+        const emsg = `Channel closed by server: ${closeMsg(f)}`;
+        this.sendImmediately(defs.ChannelCloseOk, {});
 
-      var error = new Error(emsg);
-      error.code = f.fields.replyCode;
-      error.classId = f.fields.classId;
-      error.methodId = f.fields.methodId;
-      this.emit('error', error);
+        const error = new Error(emsg);
+        error.code = f.fields.replyCode;
+        error.classId = f.fields.classId;
+        error.methodId = f.fields.methodId;
+        this.emit('error', error);
 
-      var s = stackCapture(emsg);
-      this.toClosed(s);
-      return;
-
-    case defs.BasicFlow:
-      // RabbitMQ doesn't send this, it just blocks the TCP socket
-      return this.closeWithError(f.id, "Flow not implemented",
-                                 defs.constants.NOT_IMPLEMENTED,
-                                 new Error('Flow not implemented'));
-
-    default: // assume all other things are replies
-      // Resolving the reply may lead to another RPC; to make sure we
-      // don't hold that up, clear this.reply
-      var reply = this.reply; this.reply = null;
-      // however, maybe there's an RPC waiting to go? If so, that'll
-      // fill this.reply again, restoring the invariant. This does rely
-      // on any response being recv'ed after resolving the promise,
-      // below; hence, I use synchronous defer.
-      if (this.pending.length > 0) {
-        var send = this.pending.shift();
-        this.reply = send.reply;
-        this.sendImmediately(send.method, send.fields);
+        const s = stackCapture(emsg);
+        this.toClosed(s);
+        return;
+      }
+
+      case defs.BasicFlow:
+        // RabbitMQ doesn't send this, it just blocks the TCP socket
+        return this.closeWithError(f.id, 'Flow not implemented', defs.constants.NOT_IMPLEMENTED, new Error('Flow not implemented'));
+
+      default: {
+        // assume all other things are replies
+        // Resolving the reply may lead to another RPC; to make sure we
+        // don't hold that up, clear this.reply
+        const reply = this.reply;
+        this.reply = null;
+        // however, maybe there's an RPC waiting to go? If so, that'll
+        // fill this.reply again, restoring the invariant. This does rely
+        // on any response being recv'ed after resolving the promise,
+        // below; hence, I use synchronous defer.
+        if (this.pending.length > 0) {
+          const send = this.pending.shift();
+          this.reply = send.reply;
+          this.sendImmediately(send.method, send.fields);
+        }
+        return reply(null, f);
       }
-      return reply(null, f);
     }
   }
 }
@@ -369,43 +344,40 @@ class Channel extends EventEmitter {
 // the exchange.
 
 function invalidOp(msg, stack) {
-  return function() {
+  return () => {
     throw new IllegalOperationError(msg, stack);
   };
 }
 
 function invalidateSend(ch, msg, stack) {
-  ch.sendImmediately = ch.sendOrEnqueue = ch.sendMessage =
-    invalidOp(msg, stack);
+  ch.sendImmediately = ch.sendOrEnqueue = ch.sendMessage = invalidOp(msg, stack);
 }
 
 // Kick off a message delivery given a BasicDeliver or BasicReturn
 // frame (BasicGet uses the RPC mechanism)
 function acceptDeliveryOrReturn(f) {
-  var event;
+  let event;
   if (f.id === defs.BasicDeliver) event = 'delivery';
   else if (f.id === defs.BasicReturn) event = 'return';
-  else throw fmt("Expected BasicDeliver or BasicReturn; got %s",
-                 inspect(f));
-
-  var self = this;
-  var fields = f.fields;
-  return acceptMessage(function(message) {
+  else throw fmt('Expected BasicDeliver or BasicReturn; got %s', inspect(f));
+  const fields = f.fields;
+  return acceptMessage((message) => {
     message.fields = fields;
-    self.emit(event, message);
+    this.emit(event, message);
   });
 }
 
 // Move to the state of waiting for message frames (headers, then
 // one or more content frames)
 function acceptMessage(continuation) {
-  var totalSize = 0, remaining = 0;
-  var buffers = null;
+  let totalSize = 0;
+  let remaining = 0;
+  let buffers = null;
 
-  var message = {
+  const message = {
     fields: null,
     properties: null,
-    content: null
+    content: null,
   };
 
   return headers;
@@ -421,13 +393,11 @@ function acceptMessage(continuation) {
         message.content = Buffer.alloc(0);
         continuation(message);
         return acceptDeliveryOrReturn;
-      }
-      else {
+      } else {
         return content;
       }
-    }
-    else {
-      throw "Expected headers frame after delivery";
+    } else {
+      throw 'Expected headers frame after delivery';
     }
   }
 
@@ -435,71 +405,63 @@ function acceptMessage(continuation) {
   // %%% TODO cancelled messages (sent as zero-length content frame)
   function content(f) {
     if (f.content) {
-      var size = f.content.length;
+      const size = f.content.length;
       remaining -= size;
       if (remaining === 0) {
         if (buffers !== null) {
           buffers.push(f.content);
           message.content = Buffer.concat(buffers);
-        }
-        else {
+        } else {
           message.content = f.content;
         }
         continuation(message);
         return acceptDeliveryOrReturn;
-      }
-      else if (remaining < 0) {
-        throw fmt("Too much content sent! Expected %d bytes",
-                  totalSize);
-      }
-      else {
-        if (buffers !== null)
-          buffers.push(f.content);
-        else
-          buffers = [f.content];
+      } else if (remaining < 0) {
+        throw fmt('Too much content sent! Expected %d bytes', totalSize);
+      } else {
+        if (buffers !== null) buffers.push(f.content);
+        else buffers = [f.content];
         return content;
       }
-    }
-    else throw "Expected content frame after headers"
+    } else throw 'Expected content frame after headers';
   }
 }
 
 // This adds just a bit more stuff useful for the APIs, but not
 // low-level machinery.
 class BaseChannel extends Channel {
-  constructor (connection) {
+  constructor(connection) {
     super(connection);
     this.consumers = new Map();
   }
 
   // Not sure I like the ff, it's going to be changing hidden classes
   // all over the place. On the other hand, whaddya do.
-  registerConsumer (tag, callback) {
+  registerConsumer(tag, callback) {
     this.consumers.set(tag, callback);
   }
 
-  unregisterConsumer (tag) {
+  unregisterConsumer(tag) {
     this.consumers.delete(tag);
   }
 
-  dispatchMessage (fields, message) {
-    var consumerTag = fields.consumerTag;
-    var consumer = this.consumers.get(consumerTag);
+  dispatchMessage(fields, message) {
+    const consumerTag = fields.consumerTag;
+    const consumer = this.consumers.get(consumerTag);
     if (consumer) {
       return consumer(message);
-    }
-    else {
+    } else {
       // %%% Surely a race here
-      throw new Error("Unknown consumer: " + consumerTag);
+      throw new Error(`Unknown consumer: ${consumerTag}`);
     }
   }
 
-  handleDelivery (message) {
+  handleDelivery(message) {
     return this.dispatchMessage(message.fields, message);
   }
 
-  handleCancel (fields) {
-    var result = this.dispatchMessage(fields, null);
+  handleCancel(fields) {
+    const result = this.dispatchMessage(fields, null);
     this.unregisterConsumer(fields.consumerTag);
     return result;
   }