amqplib 0.10.2 → 0.10.4

package/lib/callback_model.js

@@ -5,47 +5,275 @@
 'use strict';
 
 var defs = require('./defs');
-var inherits = require('util').inherits;
-var EventEmitter = require('events').EventEmitter;
+var EventEmitter = require('events');
 var BaseChannel = require('./channel').BaseChannel;
 var acceptMessage = require('./channel').acceptMessage;
 var Args = require('./api_args');
 
-function CallbackModel(connection) {
-  if (!(this instanceof CallbackModel))
-    return new CallbackModel(connection);
-  EventEmitter.call( this );
-  this.connection = connection;
-  var self = this;
-  ['error', 'close', 'blocked', 'unblocked'].forEach(function(ev) {
-    connection.on(ev, self.emit.bind(self, ev));
-  });
+class CallbackModel extends EventEmitter {
+  constructor (connection) {
+    super();
+    this.connection = connection;
+    var self = this;
+    ['error', 'close', 'blocked', 'unblocked'].forEach(function (ev) {
+      connection.on(ev, self.emit.bind(self, ev));
+    });
+  }
+
+  close (cb) {
+    this.connection.close(cb);
+  }
+
+  updateSecret(newSecret, reason, cb) {
+    this.connection._updateSecret(newSecret, reason, cb);
+  }
+
+  createChannel (cb) {
+    var ch = new Channel(this.connection);
+    ch.open(function (err, ok) {
+      if (err === null)
+        cb && cb(null, ch);
+      else
+        cb && cb(err);
+    });
+    return ch;
+  }
+
+  createConfirmChannel (cb) {
+    var ch = new ConfirmChannel(this.connection);
+    ch.open(function (err) {
+      if (err !== null)
+        return cb && cb(err);
+      else {
+        ch.rpc(defs.ConfirmSelect, { nowait: false },
+          defs.ConfirmSelectOk, function (err, _ok) {
+            if (err !== null)
+              return cb && cb(err);
+            else
+              cb && cb(null, ch);
+          });
+      }
+    });
+    return ch;
+  }
 }
-inherits(CallbackModel, EventEmitter);
 
-module.exports.CallbackModel = CallbackModel;
+class Channel extends BaseChannel {
+  constructor (connection) {
+    super(connection);
+    this.on('delivery', this.handleDelivery.bind(this));
+    this.on('cancel', this.handleCancel.bind(this));
+  }
+
+  // This encodes straight-forward RPC: no side-effects and return the
+  // fields from the server response. It wraps the callback given it, so
+  // the calling method argument can be passed as-is. For anything that
+  // needs to have side-effects, or needs to change the server response,
+  // use `#_rpc(...)` and remember to dereference `.fields` of the
+  // server response.
+  rpc (method, fields, expect, cb0) {
+    var cb = callbackWrapper(this, cb0);
+    this._rpc(method, fields, expect, function (err, ok) {
+      cb(err, ok && ok.fields); // in case of an error, ok will be
+
+      // undefined
+    });
+    return this;
+  }
+
+  // === Public API ===
+  open (cb) {
+    try { this.allocate(); }
+    catch (e) { return cb(e); }
+
+    return this.rpc(defs.ChannelOpen, { outOfBand: "" },
+      defs.ChannelOpenOk, cb);
+  }
+
+  close (cb) {
+    return this.closeBecause("Goodbye", defs.constants.REPLY_SUCCESS,
+      function () { cb && cb(null); });
+  }
+
+  assertQueue (queue, options, cb) {
+    return this.rpc(defs.QueueDeclare,
+      Args.assertQueue(queue, options),
+      defs.QueueDeclareOk, cb);
+  }
+
+  checkQueue (queue, cb) {
+    return this.rpc(defs.QueueDeclare,
+      Args.checkQueue(queue),
+      defs.QueueDeclareOk, cb);
+  }
+
+  deleteQueue (queue, options, cb) {
+    return this.rpc(defs.QueueDelete,
+      Args.deleteQueue(queue, options),
+      defs.QueueDeleteOk, cb);
+  }
+
+  purgeQueue (queue, cb) {
+    return this.rpc(defs.QueuePurge,
+      Args.purgeQueue(queue),
+      defs.QueuePurgeOk, cb);
+  }
+
+  bindQueue (queue, source, pattern, argt, cb) {
+    return this.rpc(defs.QueueBind,
+      Args.bindQueue(queue, source, pattern, argt),
+      defs.QueueBindOk, cb);
+  }
 
-CallbackModel.prototype.close = function(cb) {
-  this.connection.close(cb);
-};
+  unbindQueue (queue, source, pattern, argt, cb) {
+    return this.rpc(defs.QueueUnbind,
+      Args.unbindQueue(queue, source, pattern, argt),
+      defs.QueueUnbindOk, cb);
+  }
+
+  assertExchange (ex, type, options, cb0) {
+    var cb = callbackWrapper(this, cb0);
+    this._rpc(defs.ExchangeDeclare,
+      Args.assertExchange(ex, type, options),
+      defs.ExchangeDeclareOk,
+      function (e, _) { cb(e, { exchange: ex }); });
+    return this;
+  }
+
+  checkExchange (exchange, cb) {
+    return this.rpc(defs.ExchangeDeclare,
+      Args.checkExchange(exchange),
+      defs.ExchangeDeclareOk, cb);
+  }
+
+  deleteExchange (exchange, options, cb) {
+    return this.rpc(defs.ExchangeDelete,
+      Args.deleteExchange(exchange, options),
+      defs.ExchangeDeleteOk, cb);
+  }
+
+  bindExchange (dest, source, pattern, argt, cb) {
+    return this.rpc(defs.ExchangeBind,
+      Args.bindExchange(dest, source, pattern, argt),
+      defs.ExchangeBindOk, cb);
+  }
 
-function Channel(connection) {
-  BaseChannel.call(this, connection);
-  this.on('delivery', this.handleDelivery.bind(this));
-  this.on('cancel', this.handleCancel.bind(this));
-}
-inherits(Channel, BaseChannel);
+  unbindExchange (dest, source, pattern, argt, cb) {
+    return this.rpc(defs.ExchangeUnbind,
+      Args.unbindExchange(dest, source, pattern, argt),
+      defs.ExchangeUnbindOk, cb);
+  }
 
-module.exports.Channel = Channel;
+  publish (exchange, routingKey, content, options) {
+    var fieldsAndProps = Args.publish(exchange, routingKey, options);
+    return this.sendMessage(fieldsAndProps, fieldsAndProps, content);
+  }
+
+  sendToQueue (queue, content, options) {
+    return this.publish('', queue, content, options);
+  }
+
+  consume (queue, callback, options, cb0) {
+    var cb = callbackWrapper(this, cb0);
+    var fields = Args.consume(queue, options);
+    var self = this;
+    this._rpc(
+      defs.BasicConsume, fields, defs.BasicConsumeOk,
+      function (err, ok) {
+        if (err === null) {
+          self.registerConsumer(ok.fields.consumerTag, callback);
+          cb(null, ok.fields);
+        }
+        else
+          cb(err);
+      });
+    return this;
+  }
+
+  cancel (consumerTag, cb0) {
+    var cb = callbackWrapper(this, cb0);
+    var self = this;
+    this._rpc(
+      defs.BasicCancel, Args.cancel(consumerTag), defs.BasicCancelOk,
+      function (err, ok) {
+        if (err === null) {
+          self.unregisterConsumer(consumerTag);
+          cb(null, ok.fields);
+        }
+        else
+          cb(err);
+      });
+    return this;
+  }
+
+  get (queue, options, cb0) {
+    var self = this;
+    var fields = Args.get(queue, options);
+    var cb = callbackWrapper(this, cb0);
+    this.sendOrEnqueue(defs.BasicGet, fields, function (err, f) {
+      if (err === null) {
+        if (f.id === defs.BasicGetEmpty) {
+          cb(null, false);
+        }
+        else if (f.id === defs.BasicGetOk) {
+          self.handleMessage = acceptMessage(function (m) {
+            m.fields = f.fields;
+            cb(null, m);
+          });
+        }
+        else {
+          cb(new Error("Unexpected response to BasicGet: " +
+            inspect(f)));
+        }
+      }
+    });
+    return this;
+  }
+
+  ack (message, allUpTo) {
+    this.sendImmediately(
+      defs.BasicAck, Args.ack(message.fields.deliveryTag, allUpTo));
+    return this;
+  }
+
+  ackAll () {
+    this.sendImmediately(defs.BasicAck, Args.ack(0, true));
+    return this;
+  }
+
+  nack (message, allUpTo, requeue) {
+    this.sendImmediately(
+      defs.BasicNack,
+      Args.nack(message.fields.deliveryTag, allUpTo, requeue));
+    return this;
+  }
+
+  nackAll (requeue) {
+    this.sendImmediately(
+      defs.BasicNack, Args.nack(0, true, requeue));
+    return this;
+  }
+
+  reject (message, requeue) {
+    this.sendImmediately(
+      defs.BasicReject,
+      Args.reject(message.fields.deliveryTag, requeue));
+    return this;
+  }
+
+  prefetch (count, global, cb) {
+    return this.rpc(defs.BasicQos,
+      Args.prefetch(count, global),
+      defs.BasicQosOk, cb);
+  }
+
+  recover (cb) {
+    return this.rpc(defs.BasicRecover,
+      Args.recover(),
+      defs.BasicRecoverOk, cb);
+  }
+}
 
-CallbackModel.prototype.createChannel = function(cb) {
-  var ch = new Channel(this.connection);
-  ch.open(function(err, ok) {
-    if (err === null) cb && cb(null, ch);
-    else cb && cb(err);
-  });
-  return ch;
-};
 
 // Wrap an RPC callback to make sure the callback is invoked with
 // either `(null, value)` or `(error)`, i.e., never two non-null
@@ -61,267 +289,44 @@ function callbackWrapper(ch, cb) {
   } : function() {};
 }
 
-// This encodes straight-forward RPC: no side-effects and return the
-// fields from the server response. It wraps the callback given it, so
-// the calling method argument can be passed as-is. For anything that
-// needs to have side-effects, or needs to change the server response,
-// use `#_rpc(...)` and remember to dereference `.fields` of the
-// server response.
-Channel.prototype.rpc = function(method, fields, expect, cb0) {
-  var cb = callbackWrapper(this, cb0);
-  this._rpc(method, fields, expect, function(err, ok) {
-    cb(err, ok && ok.fields); // in case of an error, ok will be
-                              // undefined
-  });
-  return this;
-};
-
-// === Public API ===
-
-Channel.prototype.open = function(cb) {
-  try { this.allocate(); }
-  catch (e) { return cb(e); }
-
-  return this.rpc(defs.ChannelOpen, {outOfBand: ""},
-                  defs.ChannelOpenOk, cb);
-};
-
-Channel.prototype.close = function(cb) {
-  return this.closeBecause("Goodbye", defs.constants.REPLY_SUCCESS,
-                           function() { cb && cb(null); });
-};
-
-Channel.prototype.assertQueue = function(queue, options, cb) {
-  return this.rpc(defs.QueueDeclare,
-                  Args.assertQueue(queue, options),
-                  defs.QueueDeclareOk, cb);
-};
-
-Channel.prototype.checkQueue = function(queue, cb) {
-  return this.rpc(defs.QueueDeclare,
-                  Args.checkQueue(queue),
-                  defs.QueueDeclareOk, cb);
-};
-
-Channel.prototype.deleteQueue = function(queue, options, cb) {
-  return this.rpc(defs.QueueDelete,
-                  Args.deleteQueue(queue, options),
-                  defs.QueueDeleteOk, cb);
-};
-
-Channel.prototype.purgeQueue = function(queue, cb) {
-  return this.rpc(defs.QueuePurge,
-                  Args.purgeQueue(queue),
-                  defs.QueuePurgeOk, cb);
-};
-
-Channel.prototype.bindQueue =
-  function(queue, source, pattern, argt, cb) {
-    return this.rpc(defs.QueueBind,
-                    Args.bindQueue(queue, source, pattern, argt),
-                    defs.QueueBindOk, cb);
-  };
-
-Channel.prototype.unbindQueue =
-  function(queue, source, pattern, argt, cb) {
-    return this.rpc(defs.QueueUnbind,
-                    Args.unbindQueue(queue, source, pattern, argt),
-                    defs.QueueUnbindOk, cb);
-  };
-
-Channel.prototype.assertExchange = function(ex, type, options, cb0) {
-  var cb = callbackWrapper(this, cb0);
-  this._rpc(defs.ExchangeDeclare,
-            Args.assertExchange(ex, type, options),
-            defs.ExchangeDeclareOk,
-            function(e, _) { cb(e, {exchange: ex}); });
-  return this;
-};
-
-Channel.prototype.checkExchange = function(exchange, cb) {
-  return this.rpc(defs.ExchangeDeclare,
-                  Args.checkExchange(exchange),
-                  defs.ExchangeDeclareOk, cb);
-};
-
-Channel.prototype.deleteExchange = function(exchange, options, cb) {
-  return this.rpc(defs.ExchangeDelete,
-                  Args.deleteExchange(exchange, options),
-                  defs.ExchangeDeleteOk, cb);
-};
-
-Channel.prototype.bindExchange =
-  function(dest, source, pattern, argt, cb) {
-    return this.rpc(defs.ExchangeBind,
-                    Args.bindExchange(dest, source, pattern, argt),
-                    defs.ExchangeBindOk, cb);
-  };
-
-Channel.prototype.unbindExchange =
-  function(dest, source, pattern, argt, cb) {
-    return this.rpc(defs.ExchangeUnbind,
-                    Args.unbindExchange(dest, source, pattern, argt),
-                    defs.ExchangeUnbindOk, cb);
-  };
-
-Channel.prototype.publish =
-  function(exchange, routingKey, content, options) {
-    var fieldsAndProps = Args.publish(exchange, routingKey, options);
-    return this.sendMessage(fieldsAndProps, fieldsAndProps, content);
-  };
-
-Channel.prototype.sendToQueue = function(queue, content, options) {
-  return this.publish('', queue, content, options);
-};
-
-Channel.prototype.consume = function(queue, callback, options, cb0) {
-  var cb = callbackWrapper(this, cb0);
-  var fields = Args.consume(queue, options);
-  var self = this;
-  this._rpc(
-    defs.BasicConsume, fields, defs.BasicConsumeOk,
-    function(err, ok) {
-      if (err === null) {
-        self.registerConsumer(ok.fields.consumerTag, callback);
-        cb(null, ok.fields);
-      }
-      else cb(err);
-    });
-  return this;
-};
-
-Channel.prototype.cancel = function(consumerTag, cb0) {
-  var cb = callbackWrapper(this, cb0);
-  var self = this;
-  this._rpc(
-    defs.BasicCancel, Args.cancel(consumerTag), defs.BasicCancelOk,
-    function(err, ok) {
-      if (err === null) {
-        self.unregisterConsumer(consumerTag);
-        cb(null, ok.fields);
-      }
-      else cb(err);
-    });
-  return this;
-};
-
-Channel.prototype.get = function(queue, options, cb0) {
-  var self = this;
-  var fields = Args.get(queue, options);
-  var cb = callbackWrapper(this, cb0);
-  this.sendOrEnqueue(defs.BasicGet, fields, function(err, f) {
-    if (err === null) {
-      if (f.id === defs.BasicGetEmpty) {
-        cb(null, false);
-      }
-      else if (f.id === defs.BasicGetOk) {
-        self.handleMessage = acceptMessage(function(m) {
-          m.fields = f.fields;
-          cb(null, m);
-        });
-      }
+class ConfirmChannel extends Channel {
+  publish (exchange, routingKey,
+    content, options, cb) {
+    this.pushConfirmCallback(cb);
+    return Channel.prototype.publish.call(
+      this, exchange, routingKey, content, options);
+  }
+
+  sendToQueue (queue, content,
+    options, cb) {
+    return this.publish('', queue, content, options, cb);
+  }
+
+  waitForConfirms (k) {
+    var awaiting = [];
+    var unconfirmed = this.unconfirmed;
+    unconfirmed.forEach(function (val, index) {
+      if (val === null)
+        ; // already confirmed
       else {
-        cb(new Error("Unexpected response to BasicGet: " +
-                     inspect(f)));
+        var confirmed = new Promise(function (resolve, reject) {
+          unconfirmed[index] = function (err) {
+            if (val)
+              val(err);
+            if (err === null)
+              resolve();
+            else
+              reject(err);
+          };
+        });
+        awaiting.push(confirmed);
       }
-    }
-  });
-  return this;
-};
-
-Channel.prototype.ack = function(message, allUpTo) {
-  this.sendImmediately(
-    defs.BasicAck, Args.ack(message.fields.deliveryTag, allUpTo));
-  return this;
-};
-
-Channel.prototype.ackAll = function() {
-  this.sendImmediately(defs.BasicAck, Args.ack(0, true));
-  return this;
-};
-
-Channel.prototype.nack = function(message, allUpTo, requeue) {
-  this.sendImmediately(
-    defs.BasicNack,
-    Args.nack(message.fields.deliveryTag, allUpTo, requeue));
-  return this;
-};
-
-Channel.prototype.nackAll = function(requeue) {
-  this.sendImmediately(
-    defs.BasicNack, Args.nack(0, true, requeue))
-  return this;
-};
-
-Channel.prototype.reject = function(message, requeue) {
-  this.sendImmediately(
-    defs.BasicReject,
-    Args.reject(message.fields.deliveryTag, requeue));
-  return this;
-};
-
-Channel.prototype.prefetch = function(count, global, cb) {
-  return this.rpc(defs.BasicQos,
-                  Args.prefetch(count, global),
-                  defs.BasicQosOk, cb);
-};
-
-Channel.prototype.recover = function(cb) {
-  return this.rpc(defs.BasicRecover,
-                  Args.recover(),
-                  defs.BasicRecoverOk, cb);
-};
-
-function ConfirmChannel(connection) {
-  Channel.call(this, connection);
+    });
+    return Promise.all(awaiting).then(function () { k(); },
+      function (err) { k(err); });
+  }
 }
-inherits(ConfirmChannel, Channel);
 
+module.exports.CallbackModel = CallbackModel;
+module.exports.Channel = Channel;
 module.exports.ConfirmChannel = ConfirmChannel;
-
-CallbackModel.prototype.createConfirmChannel = function(cb) {
-  var ch = new ConfirmChannel(this.connection);
-  ch.open(function(err) {
-    if (err !== null) return cb && cb(err);
-    else {
-      ch.rpc(defs.ConfirmSelect, {nowait: false},
-             defs.ConfirmSelectOk, function(err, _ok) {
-               if (err !== null) return cb && cb(err);
-               else cb && cb(null, ch);
-             });
-    }
-  });
-  return ch;
-};
-
-ConfirmChannel.prototype.publish = function(exchange, routingKey,
-                                            content, options, cb) {
-  this.pushConfirmCallback(cb);
-  return Channel.prototype.publish.call(
-    this, exchange, routingKey, content, options);
-};
-
-ConfirmChannel.prototype.sendToQueue = function(queue, content,
-                                                options, cb) {
-  return this.publish('', queue, content, options, cb);
-};
-
-ConfirmChannel.prototype.waitForConfirms = function(k) {
-  var awaiting = [];
-  var unconfirmed = this.unconfirmed;
-  unconfirmed.forEach(function(val, index) {
-    if (val === null); // already confirmed
-    else {
-      var confirmed = new Promise(function(resolve, reject) {
-        unconfirmed[index] = function(err) {
-          if (val) val(err);
-          if (err === null) resolve();
-          else reject(err);
-        };
-      });
-      awaiting.push(confirmed);
-    }
-  });
-  return Promise.all(awaiting).then(function() { k(); },
-                                 function(err) { k(err); });
-};