amqplib 0.10.2 → 0.10.4

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();
+  };
+})();  

package/examples/tutorials/new_task.js

@@ -1,18 +1,25 @@
 #!/usr/bin/env node
 // Post a new task to the work queue
 
-var amqp = require('amqplib');
+const amqp = require('amqplib');
 
-amqp.connect('amqp://localhost').then(function(conn) {
-  return conn.createChannel().then(function(ch) {
-    var q = 'task_queue';
-    var ok = ch.assertQueue(q, {durable: true});
+const queue = 'task_queue';
+const text = process.argv.slice(2).join(' ') || "Hello World!";
 
-    return ok.then(function() {
-      var msg = process.argv.slice(2).join(' ') || "Hello World!";
-      ch.sendToQueue(q, Buffer.from(msg), {deliveryMode: true});
-      console.log(" [x] Sent '%s'", msg);
-      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.assertQueue(queue, { durable: true });
+    channel.sendToQueue(queue, Buffer.from(text), { persistent: true });
+    console.log(" [x] Sent '%s'", text);
+    await channel.close();
+  }
+  catch (err) {
+    console.warn(err);
+  }
+  finally { 
+    await connection.close();
+  };
+})();

package/examples/tutorials/receive.js

@@ -1,21 +1,26 @@
 #!/usr/bin/env node
 
-var amqp = require('amqplib');
+const amqp = require('amqplib');
 
-amqp.connect('amqp://localhost').then(function(conn) {
-  process.once('SIGINT', function() { conn.close(); });
-  return conn.createChannel().then(function(ch) {
+const queue = 'hello';
 
-    var ok = ch.assertQueue('hello', {durable: false});
+(async () => {
+  try {
+    const connection = await amqp.connect('amqp://localhost');
+    const channel = await connection.createChannel();
 
-    ok = ok.then(function(_qok) {
-      return ch.consume('hello', function(msg) {
-        console.log(" [x] Received '%s'", msg.content.toString());
-      }, {noAck: true});
+    process.once('SIGINT', async () => { 
+      await channel.close();
+      await connection.close();
     });
 
-    return ok.then(function(_consumeOk) {
-      console.log(' [*] Waiting for messages. To exit press CTRL+C');
-    });
-  });
-}).catch(console.warn);
+    await channel.assertQueue(queue, { durable: false });
+    await channel.consume(queue, (message) => {
+      console.log(" [x] Received '%s'", message.content.toString());
+    }, { noAck: true });
+
+    console.log(' [*] Waiting for messages. To exit press CTRL+C');
+  } catch (err) {
+    console.warn(err);
+  }
+})();

package/examples/tutorials/receive_logs.js

@@ -1,28 +1,30 @@
 #!/usr/bin/env node
 
-var amqp = require('amqplib');
+const amqp = require('amqplib');
 
-amqp.connect('amqp://localhost').then(function(conn) {
-  process.once('SIGINT', function() { conn.close(); });
-  return conn.createChannel().then(function(ch) {
-    var ok = ch.assertExchange('logs', 'fanout', {durable: false});
-    ok = ok.then(function() {
-      return ch.assertQueue('', {exclusive: true});
-    });
-    ok = ok.then(function(qok) {
-      return ch.bindQueue(qok.queue, 'logs', '').then(function() {
-        return qok.queue;
-      });
-    });
-    ok = ok.then(function(queue) {
-      return ch.consume(queue, logMessage, {noAck: true});
-    });
-    return ok.then(function() {
-      console.log(' [*] Waiting for logs. To exit press CTRL+C');
+const exchange = 'logs';
+
+(async () => {
+  try {
+    const connection = await amqp.connect('amqp://localhost');
+    const channel = await connection.createChannel();
+
+    process.once('SIGINT', async () => { 
+      await channel.close();
+      await connection.close();
     });
 
-    function logMessage(msg) {
-      console.log(" [x] '%s'", msg.content.toString());
-    }
-  });
-}).catch(console.warn);
+    await channel.assertExchange(exchange, 'fanout', { durable: false });
+    const { queue } = await channel.assertQueue('', { exclusive: true });
+    await channel.bindQueue(queue, exchange, '')
+
+    await channel.consume(queue, (message) => {
+      if (message) console.log(" [x] '%s'", message.content.toString());
+      else console.warn(' [x] Consumer cancelled');
+    }, { noAck: true });
+
+    console.log(' [*] Waiting for logs. To exit press CTRL+C');
+  } catch (err) {
+    console.warn(err);
+  }
+})();

package/examples/tutorials/receive_logs_direct.js

@@ -1,44 +1,38 @@
 #!/usr/bin/env node
 
-var amqp = require('amqplib');
-var basename = require('path').basename;
+const amqp = require('../..');
+const { basename } = require('path');
 
-var severities = process.argv.slice(2);
-if (severities.length < 1) {
-  console.warn('Usage: %s [info] [warning] [error]',
-               basename(process.argv[1]));
+const exchange = 'direct_logs';
+const bindingKeys = process.argv.slice(2);
+if (bindingKeys.length < 1) {
+  console.warn('Usage: %s [info] [warning] [error]', basename(process.argv[1]));
   process.exit(1);
 }
 
-amqp.connect('amqp://localhost').then(function(conn) {
-  process.once('SIGINT', function() { conn.close(); });
-  return conn.createChannel().then(function(ch) {
-    var ex = 'direct_logs';
+(async () => {
+  try {
+    const connection = await amqp.connect('amqp://localhost');
+    const channel = await connection.createChannel();
 
-    var ok = ch.assertExchange(ex, 'direct', {durable: false});
-
-    ok = ok.then(function() {
-      return ch.assertQueue('', {exclusive: true});
-    });
-
-    ok = ok.then(function(qok) {
-      var queue = qok.queue;
-      return Promise.all(severities.map(function(sev) {
-        ch.bindQueue(queue, ex, sev);
-      })).then(function() { return queue; });
-    });
-
-    ok = ok.then(function(queue) {
-      return ch.consume(queue, logMessage, {noAck: true});
-    });
-    return ok.then(function() {
-      console.log(' [*] Waiting for logs. To exit press CTRL+C.');
+    process.once('SIGINT', async () => { 
+      await channel.close();
+      await connection.close();
     });
 
-    function logMessage(msg) {
-      console.log(" [x] %s:'%s'",
-                  msg.fields.routingKey,
-                  msg.content.toString());
-    }
-  });
-}).catch(console.warn);
+    await channel.assertExchange(exchange, 'direct', { durable: false });
+    const { queue } = await channel.assertQueue('', { exclusive: true });
+    await Promise.all(bindingKeys.map(async (bindingKey) => {
+      await channel.bindQueue(queue, exchange, bindingKey);
+    }));
+
+    await 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 });
+
+    console.log(' [*] Waiting for logs. To exit press CTRL+C.');
+  } catch(err) {
+    console.warn(err);
+  }
+})();

package/examples/tutorials/receive_logs_topic.js

@@ -1,43 +1,39 @@
 #!/usr/bin/env node
 
-var amqp = require('amqplib');
-var basename = require('path').basename;
+const amqp = require('../..');
+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 bindingKeys = process.argv.slice(2);
+if (bindingKeys.length < 1) {
+  console.log('Usage: %s pattern [pattern...]', basename(process.argv[1]));
   process.exit(1);
 }
 
-amqp.connect('amqp://localhost').then(function(conn) {
-  process.once('SIGINT', function() { conn.close(); });
-  return conn.createChannel().then(function(ch) {
-    var ex = 'topic_logs';
-    var ok = ch.assertExchange(ex, 'topic', {durable: false});
+(async () => {
+  try {
+    const connection = await amqp.connect('amqp://localhost');
+    const channel = await connection.createChannel();
 
-    ok = ok.then(function() {
-      return ch.assertQueue('', {exclusive: true});
+    process.once('SIGINT', async () => { 
+      await channel.close();
+      await connection.close();
     });
 
-    ok = ok.then(function(qok) {
-      var queue = qok.queue;
-      return Promise.all(keys.map(function(rk) {
-        ch.bindQueue(queue, ex, rk);
-      })).then(function() { return queue; });
-    });
+    await channel.assertExchange(exchange, 'topic', { durable: false });
+    const { queue } = await channel.assertQueue('', { exclusive: true });
+    await Promise.all(bindingKeys.map(async (bindingKey) => {
+      await channel.bindQueue(queue, exchange, bindingKey);
+    }));
 
-    ok = ok.then(function(queue) {
-      return ch.consume(queue, logMessage, {noAck: true});
-    });
-    return ok.then(function() {
-      console.log(' [*] Waiting for logs. To exit press CTRL+C.');
-    });
+    await 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 logMessage(msg) {
-      console.log(" [x] %s:'%s'",
-                  msg.fields.routingKey,
-                  msg.content.toString());
-    }
-  });
-}).catch(console.warn);
+    console.log(' [*] Waiting for logs. To exit press CTRL+C.');
+  }
+  catch (err) {
+    console.warn(err);
+  }
+})();

package/examples/tutorials/rpc_client.js

@@ -1,52 +1,49 @@
 #!/usr/bin/env node
 
-var amqp = require('amqplib');
-var basename = require('path').basename;
-var uuid = require('node-uuid');
-
-// I've departed from the form of the original RPC tutorial, which
-// needlessly introduces a class definition, and doesn't even
-// parameterise the request.
-
-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');
+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);
 }
 
-amqp.connect('amqp://localhost').then(function(conn) {
-  return conn.createChannel().then(function(ch) {
-    return new Promise(function(resolve) {
-      var corrId = uuid();
-      function maybeAnswer(msg) {
-        if (msg.properties.correlationId === corrId) {
-          resolve(msg.content.toString());
-        }
-      }
+(async () => {
+  let connection;
+  try {
+    connection = await amqp.connect('amqp://localhost');
+    const channel = await connection.createChannel();
+    const correlationId = uuid();
 
-      var ok = ch.assertQueue('', {exclusive: true})
-        .then(function(qok) { return qok.queue; });
+    const requestFib = new Promise(async (resolve) => {
+      const { queue: replyTo } = await channel.assertQueue('', { exclusive: true });
 
-      ok = ok.then(function(queue) {
-        return ch.consume(queue, maybeAnswer, {noAck: true})
-          .then(function() { return queue; });
-      });
+      await channel.consume(replyTo, (message) => {
+        if (!message) console.warn(' [x] Consumer cancelled');
+        else if (message.properties.correlationId === correlationId) {
+          resolve(message.content.toString());
+        }
+      }, { noAck: true });
 
-      ok = ok.then(function(queue) {
-        console.log(' [x] Requesting fib(%d)', n);
-        ch.sendToQueue('rpc_queue', Buffer.from(n.toString()), {
-          correlationId: corrId, replyTo: queue
-        });
+      await channel.assertQueue(queue, { durable: false });
+      console.log(' [x] Requesting fib(%d)', n);
+      channel.sendToQueue(queue, Buffer.from(n.toString()), { 
+        correlationId,
+        replyTo,
       });
     });
-  })
-  .then(function(fibN) {
+
+    const fibN = await requestFib;
     console.log(' [.] Got %d', fibN);
-  })
-  .finally(function() { conn.close(); });
-}).catch(console.warn);
+  }
+  catch (err) {
+    console.warn(err);
+  }
+  finally {
+    if (connection) await connection.close();
+  };
+})();  

package/examples/tutorials/rpc_server.js

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