amqplib 0.4.1 → 0.5.2

package/examples/tutorials/rpc_server.js

@@ -31,9 +31,9 @@ amqp.connect('amqp://localhost').then(function(conn) {
       console.log(' [.] fib(%d)', n);
       var response = fib(n);
       ch.sendToQueue(msg.properties.replyTo,
-                     new Buffer(response.toString()),
+                     Buffer.from(response.toString()),
                      {correlationId: msg.properties.correlationId});
       ch.ack(msg);
     }
   });
-}).then(null, console.warn);
+}).catch(console.warn);

package/examples/tutorials/send.js

@@ -1,19 +1,23 @@
 #!/usr/bin/env node
 
 var amqp = require('amqplib');
-var when = require('when');
 
 amqp.connect('amqp://localhost').then(function(conn) {
-  return when(conn.createChannel().then(function(ch) {
+  return conn.createChannel().then(function(ch) {
     var q = 'hello';
     var msg = 'Hello World!';
 
     var ok = ch.assertQueue(q, {durable: false});
-    
+
     return ok.then(function(_qok) {
-      ch.sendToQueue(q, new Buffer(msg));
+      // NB: `sentToQueue` and `publish` both return a boolean
+      // indicating whether it's OK to send again straight away, or
+      // (when `false`) that you should wait for the event `'drain'`
+      // to fire before writing again. We're just doing the one write,
+      // so we'll ignore it.
+      ch.sendToQueue(q, Buffer.from(msg));
       console.log(" [x] Sent '%s'", msg);
       return ch.close();
     });
-  })).ensure(function() { conn.close(); });
-}).then(null, console.warn);
+  }).finally(function() { conn.close(); });
+}).catch(console.warn);

package/examples/tutorials/worker.js

@@ -25,4 +25,4 @@ amqp.connect('amqp://localhost').then(function(conn) {
       }, secs * 1000);
     }
   });
-}).then(null, console.warn);
+}).catch(console.warn);

package/examples/waitForConfirms.js

@@ -12,11 +12,11 @@ function mkCallback(i) {
 amqp.connect().then(function(c) {
   c.createConfirmChannel().then(function(ch) {
     for (var i=0; i < NUM_MSGS; i++) {
-      ch.publish('amq.topic', 'whatever', new Buffer('blah'), {}, mkCallback(i)); 
+      ch.publish('amq.topic', 'whatever', Buffer.from('blah'), {}, mkCallback(i));
     }
     ch.waitForConfirms().then(function() {
       console.log('All messages done');
       c.close();
-    }, console.error);
+    }).catch(console.error);
   });
 });

package/lib/callback_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;
@@ -215,7 +215,7 @@ Channel.prototype.get = function(queue, options, cb0) {
       if (f.id === defs.BasicGetEmpty) {
         cb(null, false);
       }
-      else if (f.id = defs.BasicGetOk) {
+      else if (f.id === defs.BasicGetOk) {
         self.handleMessage = acceptMessage(function(m) {
           m.fields = f.fields;
           cb(null, m);
@@ -308,20 +308,21 @@ ConfirmChannel.prototype.sendToQueue = function(queue, content,
 };
 
 ConfirmChannel.prototype.waitForConfirms = function(k) {
-  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).then(function() { k(); },
-                              function(err) { k(err); });
+  return Promise.all(awaiting).then(function() { k(); },
+                                 function(err) { k(err); });
 };

package/lib/channel.js

@@ -16,7 +16,7 @@ var EventEmitter = require('events').EventEmitter;
 var fmt = require('util').format;
 var IllegalOperationError = require('./error').IllegalOperationError;
 var stackCapture = require('./error').stackCapture;
-
+var Buffer = require('safe-buffer').Buffer
 function Channel(connection) {
   EventEmitter.call( this );
   this.connection = connection;
@@ -286,7 +286,7 @@ function acceptMessage(continuation) {
       
       // for zero-length messages, content frames aren't required.
       if (totalSize === 0) {
-        message.content = new Buffer(0);
+        message.content = Buffer.alloc(0);
         continuation(message);
         return acceptDeliveryOrReturn;
       }

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/codec.js

@@ -1,4 +1,4 @@
-// 
+//
 //
 //
 
@@ -110,6 +110,40 @@ function encodeFieldValue(buffer, value, offset) {
         type = value['!'];
     }
 
+    // If it's a JS number, we'll have to guess what type to encode it
+    // as.
+    if (type == 'number') {
+        // Making assumptions about the kind of number (floating point
+        // v integer, signed, unsigned, size) desired is dangerous in
+        // general; however, in practice RabbitMQ uses only
+        // longstrings and unsigned integers in its arguments, and
+        // other clients generally conflate number types anyway. So
+        // the only distinction we care about is floating point vs
+        // integers, preferring integers since those can be promoted
+        // if necessary. If floating point is required, we may as well
+        // use double precision.
+        if (isFloatingPoint(val)) {
+            type = 'double';
+        }
+        else { // only signed values are used in tables by
+               // RabbitMQ. It *used* to (< v3.3.0) treat the byte 'b'
+               // type as unsigned, but most clients (and the spec)
+               // think it's signed, and now RabbitMQ does too.
+            if (val < 128 && val >= -128) {
+                type = 'byte';
+            }
+            else if (val >= -0x8000 && val < 0x8000) {
+                type = 'short'
+            }
+            else if (val >= -0x80000000 && val < 0x80000000) {
+                type = 'int';
+            }
+            else {
+                type = 'long';
+            }
+        }
+    }
+
     function tag(t) { buffer.write(t, offset); offset++; }
 
     switch (type) {
@@ -141,44 +175,36 @@ function encodeFieldValue(buffer, value, offset) {
         tag('t');
         buffer.writeUInt8((val) ? 1 : 0, offset); offset++;
         break;
-    case 'number':
-        // Making assumptions about the kind of number (floating point
-        // v integer, signed, unsigned, size) desired is dangerous in
-        // general; however, in practice RabbitMQ uses only
-        // longstrings and unsigned integers in its arguments, and
-        // other clients generally conflate number types anyway. So
-        // the only distinction we care about is floating point vs
-        // integers, preferring integers since those can be promoted
-        // if necessary. If floating point is required, we may as well
-        // use double precision.
-        if (isFloatingPoint(val)) {
-            tag('d');
-            buffer.writeDoubleBE(val, offset);
-            offset += 8;
-        }
-        else { // only signed values are used in tables by
-               // RabbitMQ. It *used* to (< v3.3.0) treat the byte 'b'
-               // type as unsigned, but most clients (and the spec)
-               // think it's signed, and now RabbitMQ does too.
-            if (val < 128 && val >= -128) {
-                tag('b');
-                buffer.writeInt8(val, offset); offset++;
-            }
-            else if (val >= -0x8000 && val < 0x8000) { //  short
-                tag('s');
-                buffer.writeInt16BE(val, offset); offset += 2;
-            }
-            else if (val >= -0x80000000 && val < 0x80000000) { // int
-                tag('I');
-                buffer.writeInt32BE(val, offset); offset += 4;
-            }
-            else { // long
-                tag('l');
-                ints.writeInt64BE(buffer, val, offset); offset += 8;
-            }
-        }
+    // These are the types that are either guessed above, or
+    // explicitly given using the {'!': type} notation.
+    case 'double':
+    case 'float64':
+        tag('d');
+        buffer.writeDoubleBE(val, offset);
+        offset += 8;
+        break;
+    case 'byte':
+    case 'int8':
+        tag('b');
+        buffer.writeInt8(val, offset); offset++;
+        break;
+    case 'short':
+    case 'int16':
+        tag('s');
+        buffer.writeInt16BE(val, offset); offset += 2;
         break;
-    // Now for exotic types, those can only be denoted by using
+    case 'int':
+    case 'int32':
+        tag('I');
+        buffer.writeInt32BE(val, offset); offset += 4;
+        break;
+    case 'long':
+    case 'int64':
+        tag('l');
+        ints.writeInt64BE(buffer, val, offset); offset += 8;
+        break;
+
+    // Now for exotic types, those can _only_ be denoted by using
     // `{'!': type, value: val}
     case 'timestamp':
         tag('T');

package/lib/connect.js

@@ -76,13 +76,22 @@ function openFrames(vhost, query, credentials, extraClientProperties) {
   };
 }
 
-// Decide on credentials based on what we're supplied
+// Decide on credentials based on what we're supplied. Note that in a
+// parsed URL, the auth part is already URL-decoded, so e.g., '%3a' in
+// the URL is already decoded to ':'. This is a bit unhelpful, as it
+// means we can't tell whether a colon is a separator, or part of the
+// username. Assume no colons in usernames.
 function credentialsFromUrl(parts) {
   var user = 'guest', passwd = 'guest';
   if (parts.auth) {
-    var auth = parts.auth.split(':');
-    user = auth[0];
-    passwd = auth[1];
+    var colon = parts.auth.indexOf(':')
+    if (colon == -1) {
+      user = parts.auth;
+      passwd = '';
+    } else {
+      user = parts.auth.substring(0, colon);
+      passwd = parts.auth.substring(colon+1);
+    }
   }
   return credentials.plain(user, passwd);
 }
@@ -110,15 +119,23 @@ function connect(url, socketOptions, openCallback) {
     sockopts.port = url.port || ((protocol === 'amqp:') ? 5672 : 5671);
 
     var user, pass;
-    if (!url.username) {
-      user = 'guest';
-      pass = url.password || 'guest';
+    // Only default if both are missing, to have the same behaviour as
+    // the stringly URL.
+    if (url.username == undefined && url.password == undefined) {
+      user = 'guest'; pass = 'guest';
     } else {
-      user = url.username;
-      pass = url.password;
+      user = url.username || '';
+      pass = url.password || '';
     }
 
-    fields = openFrames(url.vhost, null, sockopts.credentials || credentials.plain(user, pass), extraClientProperties);
+    var config = {
+      locale: url.locale,
+      channelMax: url.channelMax,
+      frameMax: url.frameMax,
+      heartbeat: url.heartbeat,
+    };
+
+    fields = openFrames(url.vhost, config, sockopts.credentials || credentials.plain(user, pass), extraClientProperties);
   } else {
     var parts = URL.parse(url, true); // yes, parse the query string
     protocol = parts.protocol;
@@ -159,8 +176,11 @@ function connect(url, socketOptions, openCallback) {
   }
 
   if (timeout) {
-    sock.setTimeout(
-      timeout, openCallback.bind(this, new Error('connect ETIMEDOUT')));
+    sock.setTimeout(timeout, function() {
+      sock.end();
+      sock.destroy();
+      openCallback(new Error('connect ETIMEDOUT'));
+    });
   }
 
   sock.once('error', function(err) {
@@ -170,3 +190,4 @@ function connect(url, socketOptions, openCallback) {
 }
 
 module.exports.connect = connect;
+module.exports.credentialsFromUrl = credentialsFromUrl;

package/lib/connection.js

@@ -9,6 +9,7 @@ var constants = defs.constants;
 var frame = require('./frame');
 var HEARTBEAT = frame.HEARTBEAT;
 var Mux = require('./mux').Mux;
+var Buffer = require('safe-buffer').Buffer
 
 var Duplex =
   require('stream').Duplex ||
@@ -43,7 +44,7 @@ function Connection(underlying) {
   this.muxer = new Mux(stream);
 
   // frames
-  this.rest = new Buffer(0);
+  this.rest = Buffer.alloc(0);
   this.frameMax = constants.FRAME_MIN_SIZE;
   this.sentSinceLastCheck = false;
   this.recvSinceLastCheck = false;
@@ -148,7 +149,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 +162,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 +206,7 @@ C.open = function(allFields, openCallback0) {
       return;
     }
     send(defs.ConnectionStartOk);
-    await(afterStartOk);
+    wait(afterStartOk);
   }
 
   function afterStartOk(reply) {
@@ -550,7 +551,7 @@ C.sendMessage = function(channel,
   var allLen = methodHeaderLen + bodyLen;
 
   if (allLen < SINGLE_CHUNK_THRESHOLD) {
-    var all = new Buffer(allLen);
+    var all = Buffer.alloc(allLen);
     var offset = mframe.copy(all, 0);
     offset += pframe.copy(all, offset);
 
@@ -560,7 +561,7 @@ C.sendMessage = function(channel,
   }
   else {
     if (methodHeaderLen < SINGLE_CHUNK_THRESHOLD) {
-      var both = new Buffer(methodHeaderLen);
+      var both = Buffer.alloc(methodHeaderLen);
       var offset = mframe.copy(both, 0);
       pframe.copy(both, offset);
       buffer.write(both);

package/lib/credentials.js

@@ -8,19 +8,22 @@
 //  * PLAIN (send username and password in the plain)
 //  * EXTERNAL (assume the server will figure out who you are from
 //    context, i.e., your SSL certificate)
+var Buffer = require('safe-buffer').Buffer
 
 module.exports.plain = function(user, passwd) {
   return {
     mechanism: 'PLAIN',
     response: function() {
-      return new Buffer(['', user, passwd].join(String.fromCharCode(0)))
-    }
+      return Buffer.from(['', user, passwd].join(String.fromCharCode(0)))
+    },
+    username: user,
+    password: passwd
   }
 }
 
 module.exports.external = function() {
   return {
     mechanism: 'EXTERNAL',
-    response: function() { return new Buffer(''); }
+    response: function() { return Buffer.from(''); }
   }
 }