amqplib 0.4.0 → 0.5.1

package/lib/channel_model.js

@@ -5,7 +5,7 @@
 'use strict';
 
 var defs = require('./defs');
-var when = require('when'), defer = when.defer;
+var Promise = require('bluebird');
 var inherits = require('util').inherits;
 var EventEmitter = require('events').EventEmitter;
 var BaseChannel = require('./channel').BaseChannel;
@@ -29,12 +29,7 @@ module.exports.ChannelModel = ChannelModel;
 var CM = ChannelModel.prototype;
 
 CM.close = function() {
-  var closed = defer();
-  this.connection.close(function (err) {
-    if (err === null) closed.resolve();
-    else closed.reject(err);
-  });
-  return closed.promise;
+  return Promise.fromCallback(this.connection.close.bind(this.connection));
 };
 
 // Channels
@@ -59,17 +54,18 @@ var C = Channel.prototype;
 // response's fields; this is intended to be suitable for implementing
 // API procedures.
 C.rpc = function(method, fields, expect) {
-  var reply = defer();
-  this._rpc(method, fields, expect, function(err, f) {
-    if (err !== null) reply.reject(err);
-    else reply.resolve(f.fields);
+  var self = this;
+  return Promise.fromCallback(function(cb) {
+    return self._rpc(method, fields, expect, cb);
+  })
+  .then(function(f) {
+    return f.fields;
   });
-  return reply.promise;
 };
 
 // Do the remarkably simple channel open handshake
 C.open = function() {
-  return when.try(this.allocate.bind(this)).then(
+  return Promise.try(this.allocate.bind(this)).then(
     function(ch) {
       return ch.rpc(defs.ChannelOpen, {outOfBand: ""},
                     defs.ChannelOpenOk);
@@ -77,10 +73,11 @@ C.open = function() {
 };
 
 C.close = function() {
-  var closed = defer();
-  this.closeBecause("Goodbye", defs.constants.REPLY_SUCCESS,
-                    closed.resolve)
-  return closed.promise;
+  var self = this;
+  return Promise.fromCallback(function(cb) {
+    return self.closeBecause("Goodbye", defs.constants.REPLY_SUCCESS,
+                    cb);
+  });
 };
 
 // === Public API, declaring queues and stuff ===
@@ -151,7 +148,7 @@ C.bindExchange = function(dest, source, pattern, argt) {
 C.unbindExchange = function(dest, source, pattern, argt) {
   return this.rpc(defs.ExchangeUnbind,
                   Args.unbindExchange(dest, source, pattern, argt),
-                  defs.ExchangeUnbindOk);  
+                  defs.ExchangeUnbindOk);
 };
 
 // Working with messages
@@ -170,58 +167,52 @@ C.consume = function(queue, callback, options) {
   // NB we want the callback to be run synchronously, so that we've
   // registered the consumerTag before any messages can arrive.
   var fields = Args.consume(queue, options);
-  var reply = defer();
-  this._rpc(defs.BasicConsume, fields, defs.BasicConsumeOk,
-            function(err, ok) {
-              if (err === null) {
-                self.registerConsumer(ok.fields.consumerTag,
-                                      callback);
-                reply.resolve(ok.fields);
-              }
-              else reply.reject(err);
-            });
-  return reply.promise;
+  return Promise.fromCallback(function(cb) {
+    self._rpc(defs.BasicConsume, fields, defs.BasicConsumeOk, cb);
+  })
+  .then(function(ok) {
+    self.registerConsumer(ok.fields.consumerTag, callback);
+    return ok.fields;
+  });
 };
 
 C.cancel = function(consumerTag) {
   var self = this;
-  var reply = defer();
-  this._rpc(defs.BasicCancel, Args.cancel(consumerTag),
-            defs.BasicCancelOk,
-            function(err, ok) {
-              if (err === null) {
-                self.unregisterConsumer(consumerTag);
-                reply.resolve(ok.fields);
-              }
-              else reply.reject(err);
-            });
-  return reply.promise;
+  return Promise.fromCallback(function(cb) {
+    self._rpc(defs.BasicCancel, Args.cancel(consumerTag),
+          defs.BasicCancelOk,
+          cb);
+  })
+  .then(function(ok) {
+    self.unregisterConsumer(consumerTag);
+    return ok.fields;
+  });
 };
 
 C.get = function(queue, options) {
-  var reply = defer();
   var self = this;
   var fields = Args.get(queue, options);
-  this.sendOrEnqueue(defs.BasicGet, fields, function(err, f) {
-    if (err === null) {
-      if (f.id === defs.BasicGetEmpty) {
-        reply.resolve(false);
-      }
-      else if (f.id === defs.BasicGetOk) {
-        var fields = f.fields;
+  return Promise.fromCallback(function(cb) {
+    return self.sendOrEnqueue(defs.BasicGet, fields, cb);
+  })
+  .then(function(f) {
+    if (f.id === defs.BasicGetEmpty) {
+      return false;
+    }
+    else if (f.id === defs.BasicGetOk) {
+      var fields = f.fields;
+      return new Promise(function(resolve) {
         self.handleMessage = acceptMessage(function(m) {
           m.fields = fields;
-          reply.resolve(m);
+          resolve(m);
         });
-      }
-      else {
-        reply.reject(new Error("Unexpected response to BasicGet: " +
-                               inspect(f)));
-      }
+      });
     }
-    else reply.reject(err);
-  });
-  return reply.promise;
+    else {
+      throw new Error("Unexpected response to BasicGet: " +
+                             inspect(f));
+    }
+  })
 };
 
 C.ack = function(message, allUpTo) {
@@ -308,19 +299,20 @@ CC.sendToQueue = function(queue, content, options, cb) {
 };
 
 CC.waitForConfirms = function() {
-  var await = [];
+  var awaiting = [];
   var unconfirmed = this.unconfirmed;
   unconfirmed.forEach(function(val, index) {
     if (val === null); // already confirmed
     else {
-      var confirmed = defer();
-      unconfirmed[index] = function(err) {
-        if (val) val(err);
-        if (err === null) confirmed.resolve();
-        else confirmed.reject(err);
-      };
-      await.push(confirmed.promise);
+      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 when.all(await);
+  return Promise.all(awaiting);
 };

package/lib/connection.js

@@ -87,12 +87,12 @@ function channel0(connection) {
       connection.sendMethod(0, defs.ConnectionCloseOk, {});
       var emsg = fmt('Connection closed: %s', closeMsg(f));
       var s = stackCapture(emsg);
-      if (closeIsError(f.fields)) {
-        var e = new Error(emsg);
-        e.code = f.fields.replyCode;
+      var e = new Error(emsg);
+      e.code = f.fields.replyCode;
+      if (isFatalError(e)) {
         connection.emit('error', e);
       }
-      connection.toClosed(s, emsg);
+      connection.toClosed(s, e);
     }
     else if (f.id === defs.ConnectionBlocked) {
       connection.emit('blocked', f.fields.reason);
@@ -148,7 +148,7 @@ C.open = function(allFields, openCallback0) {
   // This is where we'll put our negotiated values
   var tunedOptions = Object.create(allFields);
 
-  function await(k) {
+  function wait(k) {
     self.step(function(err, frame) {
       if (err !== null) bail(err);
       else if (frame.channel !== 0) {
@@ -161,7 +161,7 @@ C.open = function(allFields, openCallback0) {
   }
 
   function expect(Method, k) {
-    await(function(frame) {
+    wait(function(frame) {
       if (frame.id === Method) k(frame);
       else {
         bail(new Error(
@@ -205,7 +205,7 @@ C.open = function(allFields, openCallback0) {
       return;
     }
     send(defs.ConnectionStartOk);
-    await(afterStartOk);
+    wait(afterStartOk);
   }
 
   function afterStartOk(reply) {
@@ -350,7 +350,7 @@ C.onSocketError = function(err) {
     this.expectSocketClose = true;
     this.emit('error', err);
     var s = stackCapture('Socket error');
-    this.toClosed(s, err.toString());
+    this.toClosed(s, err);
   }
 };
 
@@ -375,7 +375,7 @@ C.toClosing = function(capturedStack, k) {
     if (f.id === defs.ConnectionCloseOk) {
       if (k) k();
       var s = stackCapture('ConnectionCloseOk received');
-      this.toClosed(s, 'Closed by client');
+      this.toClosed(s, undefined);
     }
     else if (f.id === defs.ConnectionClose) {
       send(0, defs.ConnectionCloseOk, {});
@@ -395,9 +395,10 @@ C._closeChannels = function(capturedStack) {
 };
 
 // A close has been confirmed. Cease all communication.
-C.toClosed = function(capturedStack, msg) {
+C.toClosed = function(capturedStack, maybeErr) {
   this._closeChannels(capturedStack);
-  var info = fmt('Connection closed (%s)', msg);
+  var info = fmt('Connection closed (%s)',
+                 (maybeErr) ? maybeErr.toString() : 'by client');
   // Tidy up, invalidate enverything, dynamite the bridges.
   invalidateSend(this, info, capturedStack);
   this.accept = invalidOp(info, capturedStack);
@@ -408,7 +409,7 @@ C.toClosed = function(capturedStack, msg) {
   // This is certainly true now, if it wasn't before
   this.expectSocketClose = true;
   this.stream.end();
-  this.emit('close', msg);
+  this.emit('close', maybeErr);
 };
 
 // ===
@@ -421,9 +422,10 @@ C.startHeartbeater = function() {
                        this.checkSend.bind(this),
                        this.checkRecv.bind(this));
     hb.on('timeout', function() {
-      self.emit('error', new Error("Heartbeat timeout"));
+      var hberr = new Error("Heartbeat timeout");
+      self.emit('error', hberr);
       var s = stackCapture('Heartbeat timeout');
-      self.toClosed(s);
+      self.toClosed(s, hberr);
     });
     hb.on('beat', function() {
       self.sendHeartbeat();
@@ -629,8 +631,8 @@ function wrapStream(s) {
   }
 }
 
-function closeIsError(fields) {
-  switch (fields.replyCode) {
+function isFatalError(error) {
+  switch (error && error.code) {
   case defs.constants.CONNECTION_FORCED:
   case defs.constants.REPLY_SUCCESS:
     return false;
@@ -640,3 +642,4 @@ function closeIsError(fields) {
 }
 
 module.exports.Connection = Connection;
+module.exports.isFatalError = isFatalError;

package/lib/heartbeat.js

@@ -40,7 +40,7 @@
 //    at least twice before sending another)
 //
 // This design is based largely on RabbitMQ's heartbeating:
-// https://github.com/rabbitmq/rabbitmq-server/blob/master/src/rabbit_heartbeat.erl
+// https://github.com/rabbitmq/rabbitmq-common/blob/master/src/rabbit_heartbeat.erl
 
 // %% Yes, I could apply the same 'actually passage of time' thing to
 // %% send as well as to recv.

package/package.json

@@ -2,20 +2,20 @@
   "name": "amqplib",
   "homepage": "http://squaremo.github.io/amqp.node/",
   "main": "./channel_api.js",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "An AMQP 0-9-1 (e.g., RabbitMQ) library and client.",
   "repository": {
     "type": "git",
     "url": "https://github.com/squaremo/amqp.node.git"
   },
   "engines": {
-    "node": ">=0.8 <4 || ^4"
+    "node": ">=0.8 <6 || ^6"
   },
   "dependencies": {
     "bitsyntax": "~0.0.4",
     "buffer-more-ints": "0.0.2",
     "readable-stream": "1.x >=1.1.9",
-    "when": "~3.6.2"
+    "bluebird": "^3.4.6"
   },
   "devDependencies": {
     "mocha": "~1",

package/test/channel.js

@@ -3,7 +3,7 @@
 'use strict';
 
 var assert = require('assert');
-var defer = require('when').defer;
+var Promise = require('bluebird');
 var Channel = require('../lib/channel').Channel;
 var Connection = require('../lib/connection').Connection;
 var util = require('./util');
@@ -76,14 +76,12 @@ var DELIVER_FIELDS = {
 };
 
 function open(ch) {
-  var opened = defer();
-  ch.allocate();
-  ch._rpc(defs.ChannelOpen, {outOfBand: ''}, defs.ChannelOpenOk,
-          function(err, _) {
-            if (err === null) opened.resolve();
-            else opened.reject(err);
-          });
-  return opened.promise;
+  return Promise.try(function() {
+    ch.allocate();
+    return Promise.fromCallback(function(cb) {
+      ch._rpc(defs.ChannelOpen, {outOfBand: ''}, defs.ChannelOpenOk, cb);
+    });
+  });
 }
 
 suite("channel open and close", function() {
@@ -112,10 +110,9 @@ test("open, close", channelTest(
   function(ch, done) {
     open(ch)
       .then(function() {
-        var closed = defer();
-        ch.closeBecause("Bye", defs.constants.REPLY_SUCCESS,
-                        closed.resolve);
-        return closed.promise;
+        return new Promise(function(resolve) {
+          ch.closeBecause("Bye", defs.constants.REPLY_SUCCESS, resolve);
+        });
       })
       .then(succeed(done), fail(done));
   },
@@ -204,7 +201,7 @@ test("RPC", channelTest(
         prefetchSize: 0,
         global: false
       };
-      
+
       ch._rpc(defs.BasicQos, fields, defs.BasicQosOk, wheeboom);
       ch._rpc(defs.BasicQos, fields, defs.BasicQosOk, wheeboom);
       ch._rpc(defs.BasicQos, fields, defs.BasicQosOk, wheeboom);
@@ -233,7 +230,7 @@ test("Bad RPC", channelTest(
       assert.strictEqual(505, error.code);
       succeed(errLatch)();
     });
-    
+
     open(ch)
       .then(function() {
         ch._rpc(defs.BasicRecover, {requeue: true}, defs.BasicRecoverOk,
@@ -257,27 +254,34 @@ test("Bad RPC", channelTest(
 test("RPC on closed channel", channelTest(
   function(ch, done) {
     open(ch);
-    var close = defer(), fail1 = defer(), fail2 = defer();
-    ch.on('error', function(error) {
-      assert.strictEqual(504, error.code);
-      close.resolve();
+
+    var close = new Promise(function(resolve) {
+        ch.on('error', function(error) {
+          assert.strictEqual(504, error.code);
+          resolve();
+      });
     });
 
-    function failureCb(d) {
+    function failureCb(resolve, reject) {
       return function(err) {
-        if (err !== null) d.resolve();
-        else d.reject();
+        if (err !== null) resolve();
+        else reject();
       }
     }
 
-    ch._rpc(defs.BasicRecover, {requeue:true}, defs.BasicRecoverOk,
-            failureCb(fail1));
-    ch._rpc(defs.BasicRecover, {requeue:true}, defs.BasicRecoverOk, 
-            failureCb(fail2));
-    close.promise
-      .then(function() { return fail1.promise; })
-      .then(function() { return fail2.promise; })
-      .then(succeed(done), fail(done));
+    var fail1 = new Promise(function(resolve, reject) {
+      return ch._rpc(defs.BasicRecover, {requeue:true}, defs.BasicRecoverOk,
+        failureCb(resolve, reject));
+    });
+
+    var fail2 = new Promise(function(resolve, reject) {
+      return ch._rpc(defs.BasicRecover, {requeue:true}, defs.BasicRecoverOk,
+        failureCb(resolve, reject));
+    });
+
+    Promise.join(close, fail1, fail2)
+      .then(succeed(done))
+      .catch(fail(done));
   },
   function(send, await, done, ch) {
     await(defs.BasicRecover)()
@@ -289,7 +293,8 @@ test("RPC on closed channel", channelTest(
         }, ch);
         return await(defs.ChannelCloseOk);
       })
-      .then(succeed(done), fail(done));
+      .then(succeed(done))
+      .catch(fail(done));
   }));
 
 test("publish all < single chunk threshold", channelTest(
@@ -453,7 +458,7 @@ test("bad properties send", channelTest(
   },
   function(send, await, done, ch) {
     done();
-  }));  
+  }));
 
 test("bad consumer", channelTest(
   function(ch, done) {