amqplib 0.10.3 → 0.10.5

package/examples/tutorials/callback_api/receive_logs_direct.js

@@ -1,56 +1,57 @@
 #!/usr/bin/env node
 
-var amqp = require('amqplib/callback_api');
+const amqp = require('amqplib/callback_api');
+const { basename } = require('path');
 
-var basename = require('path').basename;
-
-var severities = process.argv.slice(2);
+const exchange = 'direct_logs';
+const severities = process.argv.slice(2);
 if (severities.length < 1) {
-  console.log('Usage %s [info] [warning] [error]',
-              basename(process.argv[1]));
+  console.log('Usage %s [info] [warning] [error]', basename(process.argv[1]));
   process.exit(1);
 }
 
-function bail(err, conn) {
-  console.error(err);
-  if (conn) conn.close(function() { process.exit(1); });
-}
-
-function on_connect(err, conn) {
-  if (err !== null) return bail(err);
-  process.once('SIGINT', function() { conn.close(); });
-
-  conn.createChannel(function(err, ch) {
-    if (err !== null) return bail(err, conn);
-    var ex = 'direct_logs', exopts = {durable: false};
-
-    ch.assertExchange(ex, 'direct', exopts);
-    ch.assertQueue('', {exclusive: true}, function(err, ok) {
-      if (err !== null) return bail(err, conn);
-
-      var queue = ok.queue, i = 0;
+amqp.connect((err, connection) => {
+  if (err) return bail(err);
+  connection.createChannel((err, channel) => {
+    if (err) return bail(err, connection);
 
-      function sub(err) {
-        if (err !== null) return bail(err, conn);
-        else if (i < severities.length) {
-          ch.bindQueue(queue, ex, severities[i], {}, sub);
-          i++;
-        }
-      }
+    process.once('SIGINT', () => {
+      channel.close(() => {
+        connection.close();
+      });
+    });
 
-      ch.consume(queue, logMessage, {noAck: true}, function(err) {
-        if (err !== null) return bail(err, conn);
-        console.log(' [*] Waiting for logs. To exit press CTRL+C.');
-        sub(null);
+    channel.assertExchange(exchange, 'direct', { durable: false }, (err) => {
+      if (err) return bail(err, connection);
+      channel.assertQueue('', { exclusive: true }, (err, { queue }) => {
+        if (err) return bail(err, connection);
+        channel.consume(queue, (message) => {
+          if (message) console.log(" [x] %s:'%s'", message.fields.routingKey, message.content.toString());
+          else console.warn(' [x] Consumer cancelled');
+        }, {noAck: true}, function(err) {
+          if (err) return bail(err, connection);
+          console.log(' [*] Waiting for logs. To exit press CTRL+C.');
+          subscribeAll(channel, queue, severities, (err) => {
+            if (err) return bail(err, connection);
+          });
+        });
       });
     });
   });
+});
+
+function subscribeAll(channel, queue, bindingKeys, cb) {
+  if (bindingKeys.length === 0) return cb();
+  const bindingKey = bindingKeys.shift();
+  channel.bindQueue(queue, exchange, bindingKey, {}, (err) => {
+    if (err) return cb(err);
+    subscribeAll(channel, queue, bindingKeys, cb);
+  });
 }
 
-function logMessage(msg) {
-  console.log(" [x] %s:'%s'",
-              msg.fields.routingKey,
-              msg.content.toString());
+function bail(err, connection) {
+  console.error(err);
+  if (connection) connection.close(() => {
+    process.exit(1);
+  });
 }
-
-amqp.connect(on_connect);

package/examples/tutorials/callback_api/receive_logs_topic.js

@@ -1,55 +1,58 @@
 #!/usr/bin/env node
 
-var amqp = require('amqplib/callback_api');
-var basename = require('path').basename;
+const amqp = require('amqplib/callback_api');
+const { basename } = require('path');
 
-var keys = process.argv.slice(2);
-if (keys.length < 1) {
-  console.log('Usage %s pattern [pattern...]',
-              basename(process.argv[1]));
+const exchange = 'topic_logs';
+const severities = process.argv.slice(2);
+if (severities.length < 1) {
+  console.log('Usage %s [info] [warning] [error]', basename(process.argv[1]));
   process.exit(1);
 }
 
-function bail(err, conn) {
-  console.error(err);
-  if (conn) conn.close(function() { process.exit(1); });
-}
-
-function on_connect(err, conn) {
-  if (err !== null) return bail(err);
-  process.once('SIGINT', function() { conn.close(); });
-
-  conn.createChannel(function(err, ch) {
-    if (err !== null) return bail(err, conn);
-    var ex = 'topic_logs', exopts = {durable: false};
-
-    ch.assertExchange(ex, 'topic', exopts);
-    ch.assertQueue('', {exclusive: true}, function(err, ok) {
-      if (err !== null) return bail(err, conn);
-
-      var queue = ok.queue, i = 0;
+amqp.connect((err, connection) => {
+  if (err) return bail(err);
+  connection.createChannel((err, channel) => {
+    if (err) return bail(err, connection);
 
-      function sub(err) {
-        if (err !== null) return bail(err, conn);
-        else if (i < keys.length) {
-          ch.bindQueue(queue, ex, keys[i], {}, sub);
-          i++;
-        }
-      }
+    process.once('SIGINT', () => {
+      channel.close(() => {
+        connection.close();
+      });
+    });
 
-      ch.consume(queue, logMessage, {noAck: true}, function(err) {
-        if (err !== null) return bail(err, conn);
-        console.log(' [*] Waiting for logs. To exit press CTRL+C.');
-        sub(null);
+    channel.assertExchange(exchange, 'topic', { durable: false }, (err) => {
+      if (err) return bail(err, connection);
+      channel.assertQueue('', { exclusive: true }, (err, { queue }) => {
+        if (err) return bail(err, connection);
+        channel.consume(queue, (message) => {
+          if (message) console.log(" [x] %s:'%s'", message.fields.routingKey, message.content.toString());
+          else console.warn(' [x] Consumer cancelled');
+        }, {noAck: true}, function(err) {
+          if (err) return bail(err, connection);
+          console.log(' [*] Waiting for logs. To exit press CTRL+C.');
+          subscribeAll(channel, queue, severities, (err) => {
+            if (err) return bail(err, connection);
+          });
+        });
       });
     });
   });
+});
+
+function subscribeAll(channel, queue, bindingKeys, cb) {
+  if (bindingKeys.length === 0) return cb();
+  const bindingKey = bindingKeys.shift();
+  channel.bindQueue(queue, exchange, bindingKey, {}, (err) => {
+    if (err) return cb(err);
+    subscribeAll(channel, queue, bindingKeys, cb);
+  });
 }
 
-function logMessage(msg) {
-  console.log(" [x] %s:'%s'",
-              msg.fields.routingKey,
-              msg.content.toString());
+function bail(err, connection) {
+  console.error(err);
+  if (connection) connection.close(() => {
+    process.exit(1);
+  });
 }
 
-amqp.connect(on_connect);

package/examples/tutorials/callback_api/rpc_client.js

@@ -1,49 +1,51 @@
 #!/usr/bin/env node
 
-var amqp = require('amqplib/callback_api');
-var basename = require('path').basename;
-var uuid = require('node-uuid');
-
-var n;
-try {
-  if (process.argv.length < 3) throw Error('Too few args');
-  n = parseInt(process.argv[2]);
-}
-catch (e) {
-  console.error(e);
+const amqp = require('amqplib/callback_api');
+const { basename } = require('path');
+const { v4: uuid } = require('uuid');
+
+const queue = 'rpc_queue';
+
+const n = parseInt(process.argv[2], 10);
+if (isNaN(n)) {
   console.warn('Usage: %s number', basename(process.argv[1]));
   process.exit(1);
 }
 
-function bail(err, conn) {
-  console.error(err);
-  if (conn) conn.close(function() { process.exit(1); });
-}
+amqp.connect((err, connection) => {
+  if (err) return bail(err);
+  connection.createChannel((err, channel) => {
+    if (err) return bail(err, connection);
+    channel.assertQueue('', { exclusive: true }, (err, { queue: replyTo }) => {
+      if (err) return bail(err, connection);
 
-function on_connect(err, conn) {
-  if (err !== null) return bail(err);
-  conn.createChannel(function(err, ch) {
-    if (err !== null) return bail(err, conn);
-
-    var correlationId = uuid();
-    function maybeAnswer(msg) {
-      if (msg.properties.correlationId === correlationId) {
-        console.log(' [.] Got %d', msg.content.toString());
-      }
-      else return bail(new Error('Unexpected message'), conn);
-      ch.close(function() { conn.close(); });
-    }
-
-    ch.assertQueue('', {exclusive: true}, function(err, ok) {
-      if (err !== null) return bail(err, conn);
-      var queue = ok.queue;
-      ch.consume(queue, maybeAnswer, {noAck:true});
-      console.log(' [x] Requesting fib(%d)', n);
-      ch.sendToQueue('rpc_queue', Buffer.from(n.toString()), {
-        replyTo: queue, correlationId: correlationId
+      const correlationId = uuid();
+      channel.consume(replyTo, (message) => {
+        if (!message) console.warn(' [x] Consumer cancelled');
+        else if (message.properties.correlationId === correlationId) {
+          console.log(' [.] Got %d', message.content.toString());
+          channel.close(() => {
+            connection.close();
+          })
+        }
+      }, { noAck: true });
+
+      channel.assertQueue(queue, { durable: false }, (err) => {
+        if (err) return bail(err, connection);
+        console.log(' [x] Requesting fib(%d)', n);
+        channel.sendToQueue(queue, Buffer.from(n.toString()), {
+          correlationId,
+          replyTo
+        });
       });
     });
   });
+});
+
+function bail(err, connection) {
+  console.error(err);
+  if (connection) connection.close(() => {
+    process.exit(1);
+  });
 }
 
-amqp.connect(on_connect);

package/examples/tutorials/callback_api/rpc_server.js

@@ -1,45 +1,55 @@
 #!/usr/bin/env node
 
-var amqp = require('amqplib/callback_api');
+const amqp = require('amqplib/callback_api');
+
+const queue = 'rpc_queue';
+
+amqp.connect((err, connection) => {
+  if (err) return bail(err);
+  connection.createChannel((err, channel) => {
+    if (err) return bail(err, connection);
+
+    process.once('SIGINT', () => {
+      channel.close(() => {
+        connection.close();
+      });
+    });
+
+    channel.assertQueue(queue, { durable: false }, (err) => {
+      if (err) return bail(err, connection);
+      channel.prefetch(1);
+      channel.consume(queue, (message) => {
+        const n = parseInt(message.content.toString(), 10);
+        console.log(' [.] fib(%d)', n);
+        const response = fib(n);
+        channel.sendToQueue(message.properties.replyTo, Buffer.from(response.toString()), {
+          correlationId: message.properties.correlationId
+        });
+        channel.ack(message);
+      }, { noAck: false }, function(err) {
+        if (err) return bail(err, conn);
+        console.log(' [x] Awaiting RPC requests. To exit press CTRL+C.');
+      });
+    });
+  });
+});
 
 function fib(n) {
-  var a = 0, b = 1;
-  for (var i=0; i < n; i++) {
-    var c = a + b;
+  // Do it the ridiculous, but not most ridiculous, way. For better,
+  // see http://nayuki.eigenstate.org/page/fast-fibonacci-algorithms
+  let a = 0, b = 1;
+  for (let i=0; i < n; i++) {
+    let c = a + b;
     a = b; b = c;
   }
   return a;
 }
 
-function bail(err, conn) {
-  console.error(err);
-  if (conn) conn.close(function() { process.exit(1); });
-}
-
-function on_connect(err, conn) {
-  if (err !== null) return bail(err);
-
-  process.once('SIGINT', function() { conn.close(); });
-
-  var q = 'rpc_queue';
 
-  conn.createChannel(function(err, ch) {
-    ch.assertQueue(q, {durable: false});
-    ch.prefetch(1);
-    ch.consume(q, reply, {noAck:false}, function(err) {
-      if (err !== null) return bail(err, conn);
-      console.log(' [x] Awaiting RPC requests');
-    });
-
-    function reply(msg) {
-      var n = parseInt(msg.content.toString());
-      console.log(' [.] fib(%d)', n);
-      ch.sendToQueue(msg.properties.replyTo,
-                     Buffer.from(fib(n).toString()),
-                     {correlationId: msg.properties.correlationId});
-      ch.ack(msg);
-    }
+function bail(err, connection) {
+  console.error(err);
+  if (connection) connection.close(() => {
+    process.exit(1);
   });
 }
 
-amqp.connect(on_connect);

package/examples/tutorials/callback_api/send.js

@@ -1,29 +1,28 @@
 #!/usr/bin/env node
 
-var amqp = require('amqplib/callback_api');
+const amqp = require('amqplib/callback_api');
 
-function bail(err, conn) {
-  console.error(err);
-  if (conn) conn.close(function() { process.exit(1); });
-}
-
-function on_connect(err, conn) {
-  if (err !== null) return bail(err);
+const queue = 'hello';
+const text = 'Hello World!';
 
-  var q = 'hello';
-  var msg = 'Hello World!';
-
-  function on_channel_open(err, ch) {
-    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, Buffer.from(msg));
-      console.log(" [x] Sent '%s'", msg);
-      ch.close(function() { conn.close(); });
+amqp.connect((err, connection) => {
+  if (err) return bail(err);
+  connection.createChannel((err, channel) => {
+    if (err) return bail(err, connection);
+    channel.assertQueue(queue, { durable: false }, (err) => {
+      if (err) return bail(err, connection);
+      channel.sendToQueue(queue, Buffer.from(text));
+      console.log(" [x] Sent '%s'", text);
+      channel.close(() => {
+        connection.close();
+      });
     });
-  }
+  });
+});
 
-  conn.createChannel(on_channel_open);
+function bail(err, connection) {
+  console.error(err);
+  if (connection) connection.close(() => {
+    process.exit(1);
+  });
 }
-
-amqp.connect(on_connect);

package/examples/tutorials/callback_api/worker.js

@@ -1,35 +1,39 @@
 #!/usr/bin/env node
 
-var amqp = require('amqplib/callback_api');
+const amqp = require('amqplib/callback_api');
 
-function bail(err, conn) {
-  console.error(err);
-  if (conn) conn.close(function() { process.exit(1); });
-}
+const queue = 'task_queue';
 
-function on_connect(err, conn) {
-  if (err !== null) return bail(err);
-  process.once('SIGINT', function() { conn.close(); });
-  
-  var q = 'task_queue';
+amqp.connect((err, connection) => {
+  if (err) return bail(err);
+  connection.createChannel((err, channel) => {
+    if (err) return bail(err, connection);
+
+    process.once('SIGINT', () => {
+      channel.close(() => {
+        connection.close();
+      });
+    });
 
-  conn.createChannel(function(err, ch) {
-    if (err !== null) return bail(err, conn);
-    ch.assertQueue(q, {durable: true}, function(err, _ok) {
-      ch.consume(q, doWork, {noAck: false});
+    channel.assertQueue(queue, { durable: true }, (err, { queue }) => {
+      if (err) return bail(err, connection);
+      channel.consume(queue, (message) => {
+        const text = message.content.toString();
+        console.log(" [x] Received '%s'", text);
+        const seconds = text.split('.').length - 1;
+        setTimeout(() => {
+          console.log(" [x] Done");
+          channel.ack(message);
+        }, seconds * 1000);
+      }, { noAck: false });
       console.log(" [*] Waiting for messages. To exit press CTRL+C");
     });
+  });
+});
 
-    function doWork(msg) {
-      var body = msg.content.toString();
-      console.log(" [x] Received '%s'", body);
-      var secs = body.split('.').length - 1;
-      setTimeout(function() {
-        console.log(" [x] Done");
-        ch.ack(msg);
-      }, secs * 1000);
-    }
+function bail(err, connection) {
+  console.error(err);
+  if (connection) connection.close(() => {
+    process.exit(1);
   });
 }
-
-amqp.connect(on_connect);

package/examples/tutorials/emit_log.js

@@ -1,19 +1,24 @@
 #!/usr/bin/env node
 
-var amqp = require('amqplib');
+const amqp = require('amqplib');
 
-amqp.connect('amqp://localhost').then(function(conn) {
-  return conn.createChannel().then(function(ch) {
-    var ex = 'logs';
-    var ok = ch.assertExchange(ex, 'fanout', {durable: false})
+const exchange = 'logs';
+const text = process.argv.slice(2).join(' ') || 'info: Hello World!';
 
-    var message = process.argv.slice(2).join(' ') ||
-      'info: Hello World!';
-
-    return ok.then(function() {
-      ch.publish(ex, '', Buffer.from(message));
-      console.log(" [x] Sent '%s'", message);
-      return ch.close();
-    });
-  }).finally(function() { conn.close(); });
-}).catch(console.warn);
+(async () => {
+  let connection;
+  try {
+    connection = await amqp.connect('amqp://localhost');
+    const channel = await connection.createChannel();
+    await channel.assertExchange(exchange, 'fanout', { durable: false });
+    channel.publish(exchange, '', Buffer.from(text));
+    console.log(" [x] Sent '%s'", text);
+    await channel.close();
+  }
+  catch (err) {
+    console.warn(err);
+  }
+  finally {
+    if (connection) await connection.close();
+  };
+})();  

package/examples/tutorials/emit_log_direct.js

@@ -1,20 +1,26 @@
 #!/usr/bin/env node
 
-var amqp = require('amqplib');
+const amqp = require('amqplib');
 
-var args = process.argv.slice(2);
-var severity = (args.length > 0) ? args[0] : 'info';
-var message = args.slice(1).join(' ') || 'Hello World!';
+const exchange = 'direct_logs';
+const args = process.argv.slice(2);
+const routingKey = (args.length > 0) ? args[0] : 'info';
+const text = args.slice(1).join(' ') || 'Hello World!';
 
-amqp.connect('amqp://localhost').then(function(conn) {
-  return conn.createChannel().then(function(ch) {
-    var ex = 'direct_logs';
-    var ok = ch.assertExchange(ex, 'direct', {durable: false});
-
-    return ok.then(function() {
-      ch.publish(ex, severity, Buffer.from(message));
-      console.log(" [x] Sent %s:'%s'", severity, message);
-      return ch.close();
-    });
-  }).finally(function() { conn.close(); });
-}).catch(console.warn);
+(async () => {
+  let connection;
+  try {
+    connection = await amqp.connect('amqp://localhost');
+    const channel = await connection.createChannel();
+    await channel.assertExchange(exchange, 'direct', { durable: false });
+    channel.publish(exchange, routingKey, Buffer.from(text));
+    console.log(" [x] Sent %s:'%s'", routingKey, text);
+    await channel.close();
+  }
+  catch (err) {
+    console.warn(err);
+  }
+  finally {
+    if (connection) await connection.close();
+  };
+})();  

package/examples/tutorials/emit_log_topic.js

@@ -1,19 +1,26 @@
 #!/usr/bin/env node
 
-var amqp = require('amqplib');
+const amqp = require('amqplib');
 
-var args = process.argv.slice(2);
-var key = (args.length > 0) ? args[0] : 'info';
-var message = args.slice(1).join(' ') || 'Hello World!';
+const exchange = 'topic_logs';
+const args = process.argv.slice(2);
+const routingKeys = (args.length > 0) ? args[0] : 'info';
+const text = args.slice(1).join(' ') || 'Hello World!';
 
-amqp.connect('amqp://localhost').then(function(conn) {
-  return conn.createChannel().then(function(ch) {
-    var ex = 'topic_logs';
-    var ok = ch.assertExchange(ex, 'topic', {durable: false});
-    return ok.then(function() {
-      ch.publish(ex, key, Buffer.from(message));
-      console.log(" [x] Sent %s:'%s'", key, message);
-      return ch.close();
-    });
-  }).finally(function() { conn.close(); })
-}).catch(console.log);
+(async () => {
+  let connection;
+  try {
+    connection = await amqp.connect('amqp://localhost');
+    const channel = await connection.createChannel();
+    await channel.assertExchange(exchange, 'topic', { durable: false });
+    channel.publish(exchange, routingKeys, Buffer.from(text));
+    console.log(" [x] Sent %s:'%s'", routingKeys, text);
+    await channel.close();
+  }
+  catch (err) {
+    console.warn(err);
+  }
+  finally {
+    if (connection) await connection.close();
+  };
+})();