amqplib 0.5.1 → 0.5.5

package/callback_api.js

@@ -19,3 +19,4 @@ function connect(url, options, cb) {
 
 module.exports.connect = connect;
 module.exports.credentials = require('./lib/credentials');
+module.exports.IllegalOperationError = require('./lib/error').IllegalOperationError;

package/channel_api.js

@@ -13,3 +13,4 @@ function connect(url, connOptions) {
 
 module.exports.connect = connect;
 module.exports.credentials = require('./lib/credentials');
+module.exports.IllegalOperationError = require('./lib/error').IllegalOperationError;

package/examples/headers.js

@@ -37,6 +37,6 @@ function bindAndConsume(ch, ex, q) {
 
 function send(ch, ex) {
   // The headers for a message are given as an option to `publish`:
-  ch.publish(ex.exchange, '', new Buffer('hello'), {headers: {baz: 'boo'}});
-  ch.publish(ex.exchange, '', new Buffer('world'), {headers: {foo: 'bar'}});
+  ch.publish(ex.exchange, '', Buffer.from('hello'), {headers: {baz: 'boo'}});
+  ch.publish(ex.exchange, '', Buffer.from('world'), {headers: {foo: 'bar'}});
 }

package/examples/receive_generator.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+'use strict';
+const co = require('co');
+const amqp = require('amqplib');
+const readline = require('readline');
+
+co(function* () {
+  const myConsumer = (msg) => {
+    if (msg !== null) {
+      console.log('consuming message %s in generator', JSON.stringify(msg.content.toString()));
+    }
+  };
+  const conn = yield amqp.connect('amqp://localhost');
+  try {
+    // create a message to consume
+    const q = 'hello';
+    const msg = 'Hello World!';
+    const channel = yield conn.createChannel();
+    yield channel.assertQueue(q);
+    channel.sendToQueue(q, Buffer.from(msg));
+    console.log(" [x] Sent '%s'", msg);
+    // consume the message
+    yield channel.consume(q, myConsumer, { noAck: true });
+  }
+  catch (e) {
+    throw e;
+  }
+}).catch(err => {
+  console.warn('Error:', err);
+});
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+// pend until message is consumed
+rl.question('newline to exit', () => process.exit());

package/examples/send_generators.js

@@ -21,7 +21,7 @@ co(function* () {
 
     yield channel.assertQueue(q);
 
-    channel.sendToQueue(q, new Buffer(msg));
+    channel.sendToQueue(q, Buffer.from(msg));
 
     // if message has been nacked, this will result in an error (rejected promise);
     yield channel.waitForConfirms();

package/examples/ssl.js

@@ -59,6 +59,6 @@ var open = amqp.connect('amqps://localhost', opts);
 open.then(function(conn) {
   process.on('SIGINT', conn.close.bind(conn));
   return conn.createChannel().then(function(ch) {
-    ch.sendToQueue('foo', new Buffer('Hello World!'));
+    ch.sendToQueue('foo', Buffer.from('Hello World!'));
   });
 }).then(null, console.warn);

package/examples/tutorials/callback_api/emit_log.js

@@ -17,7 +17,7 @@ function on_connect(err, conn) {
     ch.assertExchange(ex, 'fanout', {durable: false});
     var msg = process.argv.slice(2).join(' ') ||
       'info: Hello World!';
-    ch.publish(ex, '', new Buffer(msg));
+    ch.publish(ex, '', Buffer.from(msg));
     console.log(" [x] Sent '%s'", msg);
     ch.close(function() { conn.close(); });
   }

package/examples/tutorials/callback_api/emit_log_direct.js

@@ -20,7 +20,7 @@ function on_connect(err, conn) {
   function on_channel_open(err, ch) {
     if (err !== null) return bail(err, conn);
     ch.assertExchange(ex, 'direct', exopts, function(err, ok) {
-      ch.publish(ex, severity, new Buffer(message));
+      ch.publish(ex, severity, Buffer.from(message));
       ch.close(function() { conn.close(); });
     });
   }

package/examples/tutorials/callback_api/emit_log_topic.js

@@ -17,7 +17,7 @@ function on_connect(err, conn) {
   conn.createChannel(function(err, ch) {
     ch.assertExchange(ex, 'topic', exopts, function(err, ok) {
       if (err !== null) return bail(err, conn);
-      ch.publish(ex, key, new Buffer(message));
+      ch.publish(ex, key, Buffer.from(message));
       console.log(" [x] Sent %s:'%s'", key, message);
       ch.close(function() { conn.close(); });
     });

package/examples/tutorials/callback_api/new_task.js

@@ -17,7 +17,7 @@ function on_connect(err, conn) {
     ch.assertQueue(q, {durable: true}, function(err, _ok) {
       if (err !== null) return bail(err, conn);
       var msg = process.argv.slice(2).join(' ') || "Hello World!";
-      ch.sendToQueue(q, new Buffer(msg), {persistent: true});
+      ch.sendToQueue(q, Buffer.from(msg), {persistent: true});
       console.log(" [x] Sent '%s'", msg);
       ch.close(function() { conn.close(); });
     });

package/examples/tutorials/callback_api/rpc_client.js

@@ -39,7 +39,7 @@ function on_connect(err, conn) {
       var queue = ok.queue;
       ch.consume(queue, maybeAnswer, {noAck:true});
       console.log(' [x] Requesting fib(%d)', n);
-      ch.sendToQueue('rpc_queue', new Buffer(n.toString()), {
+      ch.sendToQueue('rpc_queue', Buffer.from(n.toString()), {
         replyTo: queue, correlationId: correlationId
       });
     });

package/examples/tutorials/callback_api/rpc_server.js

@@ -35,7 +35,7 @@ function on_connect(err, conn) {
       var n = parseInt(msg.content.toString());
       console.log(' [.] fib(%d)', n);
       ch.sendToQueue(msg.properties.replyTo,
-                     new Buffer(fib(n).toString()),
+                     Buffer.from(fib(n).toString()),
                      {correlationId: msg.properties.correlationId});
       ch.ack(msg);
     }

package/examples/tutorials/callback_api/send.js

@@ -17,7 +17,7 @@ function on_connect(err, conn) {
     if (err !== null) return bail(err, conn);
     ch.assertQueue(q, {durable: false}, function(err, ok) {
       if (err !== null) return bail(err, conn);
-      ch.sendToQueue(q, new Buffer(msg));
+      ch.sendToQueue(q, Buffer.from(msg));
       console.log(" [x] Sent '%s'", msg);
       ch.close(function() { conn.close(); });
     });

package/examples/tutorials/emit_log.js

@@ -11,7 +11,7 @@ amqp.connect('amqp://localhost').then(function(conn) {
       'info: Hello World!';
 
     return ok.then(function() {
-      ch.publish(ex, '', new Buffer(message));
+      ch.publish(ex, '', Buffer.from(message));
       console.log(" [x] Sent '%s'", message);
       return ch.close();
     });

package/examples/tutorials/emit_log_direct.js

@@ -12,7 +12,7 @@ amqp.connect('amqp://localhost').then(function(conn) {
     var ok = ch.assertExchange(ex, 'direct', {durable: false});
 
     return ok.then(function() {
-      ch.publish(ex, severity, new Buffer(message));
+      ch.publish(ex, severity, Buffer.from(message));
       console.log(" [x] Sent %s:'%s'", severity, message);
       return ch.close();
     });

package/examples/tutorials/emit_log_topic.js

@@ -11,7 +11,7 @@ amqp.connect('amqp://localhost').then(function(conn) {
     var ex = 'topic_logs';
     var ok = ch.assertExchange(ex, 'topic', {durable: false});
     return ok.then(function() {
-      ch.publish(ex, key, new Buffer(message));
+      ch.publish(ex, key, Buffer.from(message));
       console.log(" [x] Sent %s:'%s'", key, message);
       return ch.close();
     });

package/examples/tutorials/new_task.js

@@ -10,7 +10,7 @@ amqp.connect('amqp://localhost').then(function(conn) {
 
     return ok.then(function() {
       var msg = process.argv.slice(2).join(' ') || "Hello World!";
-      ch.sendToQueue(q, new Buffer(msg), {deliveryMode: true});
+      ch.sendToQueue(q, Buffer.from(msg), {deliveryMode: true});
       console.log(" [x] Sent '%s'", msg);
       return ch.close();
     });

package/examples/tutorials/rpc_client.js

@@ -40,7 +40,7 @@ amqp.connect('amqp://localhost').then(function(conn) {
 
       ok = ok.then(function(queue) {
         console.log(' [x] Requesting fib(%d)', n);
-        ch.sendToQueue('rpc_queue', new Buffer(n.toString()), {
+        ch.sendToQueue('rpc_queue', Buffer.from(n.toString()), {
           correlationId: corrId, replyTo: queue
         });
       });

package/examples/tutorials/rpc_server.js

@@ -31,7 +31,7 @@ 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);
     }

package/examples/tutorials/send.js

@@ -15,7 +15,7 @@ amqp.connect('amqp://localhost').then(function(conn) {
       // (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, new Buffer(msg));
+      ch.sendToQueue(q, Buffer.from(msg));
       console.log(" [x] Sent '%s'", msg);
       return ch.close();
     });

package/examples/waitForConfirms.js

@@ -12,7 +12,7 @@ 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');

package/lib/api_args.js

@@ -58,6 +58,8 @@ Args.assertQueue = function(queue, options) {
                options.deadLetterRoutingKey);
   setIfDefined(argt, 'x-max-length', options.maxLength);
   setIfDefined(argt, 'x-max-priority', options.maxPriority);
+  setIfDefined(argt, 'x-overflow', options.overflow);
+  setIfDefined(argt, 'x-queue-mode', options.queueMode);
 
   return {
     queue: queue,

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;
@@ -33,6 +33,12 @@ function Channel(connection) {
   this.on('nack', this.handleConfirm.bind(this, function(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'));
+    }
+  })
   // message frame state machine
   this.handleMessage = acceptDeliveryOrReturn;
 }
@@ -103,9 +109,10 @@ C._rpc = function(method, fields, expect, cb) {
         // We have detected a problem, so it's up to us to close the
         // channel
         var expectedName = methodName(expect);
+
         var e = new Error(fmt("Expected %s; got %s",
                               expectedName, inspect(f, false)));
-        self.closeWithError(fmt('Expected %s; got %s',
+        self.closeWithError(f.id, fmt('Expected %s; got %s',
                                 expectedName, methodName(f.id)),
                             defs.constants.UNEXPECTED_FRAME, e);
         return cb(e);
@@ -124,7 +131,11 @@ C._rpc = function(method, fields, expect, cb) {
         ? fmt("Operation failed: %s; %s",
               methodName(method), closeMsg(err))
         : fmt("Channel closed by server: %s", closeMsg(err));
-      return cb(new Error(e));
+      var closeFrameError = new Error(e);
+      closeFrameError.code = err.fields.replyCode;
+      closeFrameError.classId = err.fields.classId;
+      closeFrameError.methodId = err.fields.methodId;
+      return cb(closeFrameError);
     }
   }
 
@@ -186,7 +197,7 @@ C.toClosing = function(capturedStack, k) {
 };
 
 C._rejectPending = function() {
-  function rej(r) { 
+  function rej(r) {
     r(new Error("Channel ended, no reply will be forthcoming"));
   }
   if (this.reply !== null) rej(this.reply);
@@ -210,10 +221,15 @@ C.closeBecause = function(reason, code, 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`).
-C.closeWithError = function(reason, code, error) {
+C.closeWithError = function(id, reason, code, error) {
   var self = this;
   this.closeBecause(reason, code, function() {
     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);
   });
 };
@@ -232,15 +248,15 @@ C.acceptMessageFrame = function(f) {
   }
   catch (msg) {
     if (typeof msg === 'string') {
-      this.closeWithError(msg, defs.constants.UNEXPECTED_FRAME,
+      this.closeWithError(f.id, msg, defs.constants.UNEXPECTED_FRAME,
                           new Error(msg));
     }
     else if (msg instanceof Error) {
-      this.closeWithError('Error while processing message',
+      this.closeWithError(f.id, 'Error while processing message',
                           defs.constants.INTERNAL_ERROR, msg);
     }
     else {
-      this.closeWithError('Internal error while processing message',
+      this.closeWithError(f.id, 'Internal error while processing message',
                           defs.constants.INTERNAL_ERROR,
                           new Error(msg.toString()));
     }
@@ -283,15 +299,15 @@ function acceptMessage(continuation) {
     if (f.id === defs.BasicProperties) {
       message.properties = f.fields;
       totalSize = remaining = f.size;
-      
+
       // 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;
       }
       else {
-        return content;        
+        return content;
       }
     }
     else {
@@ -405,6 +421,8 @@ C.accept = function(f) {
 
     var 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);
@@ -413,7 +431,7 @@ C.accept = function(f) {
 
   case defs.BasicFlow:
     // RabbitMQ doesn't send this, it just blocks the TCP socket
-    return this.closeWithError("Flow not implemented",
+    return this.closeWithError(f.id, "Flow not implemented",
                                defs.constants.NOT_IMPLEMENTED,
                                new Error('Flow not implemented'));
 

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

@@ -6,7 +6,7 @@
 
 'use strict';
 
-var URL = require('url');
+var URL = require('url-parse');
 var QS = require('querystring');
 var Connection = require('./connection').Connection;
 var fmt = require('util').format;
@@ -76,13 +76,12 @@ function openFrames(vhost, query, credentials, extraClientProperties) {
   };
 }
 
-// Decide on credentials based on what we're supplied
+// Decide on credentials based on what we're supplied.
 function credentialsFromUrl(parts) {
   var user = 'guest', passwd = 'guest';
-  if (parts.auth) {
-    var auth = parts.auth.split(':');
-    user = auth[0];
-    passwd = auth[1];
+  if (parts.username != '' || parts.password != '') {
+    user = (parts.username) ? unescape(parts.username) : '';
+    passwd = (parts.password) ? unescape(parts.password) : '';
   }
   return credentials.plain(user, passwd);
 }
@@ -110,17 +109,25 @@ 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
+    var parts = URL(url, true); // yes, parse the query string
     protocol = parts.protocol;
     sockopts.host = parts.hostname;
     sockopts.port = parseInt(parts.port) || ((protocol === 'amqp:') ? 5672 : 5671);
@@ -159,8 +166,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 +180,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;
@@ -204,6 +205,7 @@ C.open = function(allFields, openCallback0) {
                          allFields.mechanism)));
       return;
     }
+    self.serverProperties = start.fields.serverProperties;
     send(defs.ConnectionStartOk);
     wait(afterStartOk);
   }
@@ -464,7 +466,7 @@ C.freshChannel = function(channel, options) {
 C.releaseChannel = function(channel) {
   this.freeChannels.clear(channel);
   var buffer = this.channels[channel].buffer;
-  this.muxer.unpipeFrom(buffer);
+  buffer.end(); // will also cause it to be unpiped
   this.channels[channel] = null;
 };
 
@@ -550,7 +552,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 +562,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,36 @@
 //  * 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
+var codec = require('./codec')
 
 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.amqplain = function(user, passwd) {
+  return {
+    mechanism: 'AMQPLAIN',
+    response: function() {
+      const buffer = Buffer.alloc(16384);
+      const size = codec.encodeTable(buffer, { LOGIN: user, PASSWORD: passwd}, 0);
+      return buffer.slice(4, size);
+    },
+    username: user,
+    password: passwd
   }
 }
 
 module.exports.external = function() {
   return {
     mechanism: 'EXTERNAL',
-    response: function() { return new Buffer(''); }
+    response: function() { return Buffer.from(''); }
   }
 }