amqplib 0.10.3 → 0.10.5

package/examples/headers.js

@@ -1,25 +1,20 @@
 #!/usr/bin/env node
 
-// Example of using a headers exchange
-
-var amqp = require('../')
-
-amqp.connect().then(function(conn) {
-  return conn.createChannel().then(withChannel);
-}, console.error);
-
-function withChannel(ch) {
-  // NB the type of the exchange is 'headers'
-  ch.assertExchange('matching exchange', 'headers').then(function(ex) {
-    ch.assertQueue().then(function(q) {
-      bindAndConsume(ch, ex, q).then(function() {
-        send(ch, ex);
-      });
-    });
+const amqp = require('../');
+
+(async () => {
+
+  const connection = await amqp.connect();
+  const channel = await connection.createChannel();
+
+  process.once('SIGINT', async () => {
+    await channel.close();
+    await connection.close();
   });
-}
 
-function bindAndConsume(ch, ex, q) {
+  const { exchange } = await channel.assertExchange('matching exchange', 'headers');
+  const { queue } = await channel.assertQueue();
+
   // When using a headers exchange, the headers to be matched go in
   // the binding arguments. The routing key is ignore, so best left
   // empty.
@@ -27,16 +22,19 @@ function bindAndConsume(ch, ex, q) {
   // 'x-match' is 'all' or 'any', meaning "all fields must match" or
   // "at least one field must match", respectively. The values to be
   // matched go in subsequent fields.
-  ch.bindQueue(q.queue, ex.exchange, '', {'x-match': 'any',
-                                          'foo': 'bar',
-                                          'baz': 'boo'});
-  return ch.consume(q.queue, function(msg) {
-    console.log(msg.content.toString());
-  }, {noAck: true});
-}
-
-function send(ch, ex) {
-  // The headers for a message are given as an option to `publish`:
-  ch.publish(ex.exchange, '', Buffer.from('hello'), {headers: {baz: 'boo'}});
-  ch.publish(ex.exchange, '', Buffer.from('world'), {headers: {foo: 'bar'}});
-}
+  await channel.bindQueue(queue, exchange, '', {
+    'x-match': 'any',
+    'foo': 'bar',
+    'baz': 'boo'
+  });
+
+  await channel.consume(queue, (message) => {
+    console.log(message.content.toString());
+  }, { noAck: true });
+
+  channel.publish(exchange, '', Buffer.from('hello'), { headers: { baz: 'boo' }});
+  channel.publish(exchange, '', Buffer.from('hello'), { headers: { foo: 'bar' }});
+  channel.publish(exchange, '', Buffer.from('lost'), { headers: { meh: 'nah' }});
+
+  console.log(' [x] To exit press CTRL+C.');
+})();

package/examples/ssl.js

@@ -18,8 +18,8 @@
 //
 //     openssl s_client -connect localhost:5671
 
-var amqp = require('../');
-var fs = require('fs');
+const amqp = require('../');
+const fs = require('fs');
 
 // Assemble the SSL options; for verification we need at least
 // * a certificate to present to the server ('cert', in PEM format)
@@ -34,7 +34,7 @@ var fs = require('fs');
 // to use `rejectUnauthorized: false`.
 
 // Options for full client and server verification:
-var opts = {
+const opts = {
   cert: fs.readFileSync('../etc/client/cert.pem'),
   key: fs.readFileSync('../etc/client/key.pem'),
   // cert and key or
@@ -49,16 +49,22 @@ var opts = {
 //     {verify, verify_none},
 //     {fail_if_no_peer_cert,false}
 //
-// var opts = {  ca: [fs.readFileSync('../etc/testca/cacert.pem')] };
+// const opts = {  ca: [fs.readFileSync('../etc/testca/cacert.pem')] };
 
 // Option to use the SSL client certificate for authentication
 // opts.credentials = amqp.credentials.external();
 
-var open = amqp.connect('amqps://localhost', opts);
+(async () => {
+  const connection = await amqp.connect('amqp://localhost', opts);
+  const channel = await connection.createChannel();
 
-open.then(function(conn) {
-  process.on('SIGINT', conn.close.bind(conn));
-  return conn.createChannel().then(function(ch) {
-    ch.sendToQueue('foo', Buffer.from('Hello World!'));
+  process.on('SIGINT', async () => {
+    await channel.close();
+    await connection.close();
   });
-}).then(null, console.warn);
+
+  channel.sendToQueue('foo', Buffer.from('Hello World!'));
+
+  console.log(' [x] To exit press CTRL+C.');
+})();
+

package/examples/stream_queues/README.md

@@ -0,0 +1,40 @@
+RabbitMQ Stream Examples 
+---
+The [stream queues](https://www.rabbitmq.com/streams.html) are available starting from RabbitMQ 3.9
+
+These examples show how to use stream queues with the lib.
+
+Send a message to a stream queue
+```
+node send_stream.js
+```
+
+Receive all the messages from stream queue:
+```
+node receive_stream.js
+```
+
+Consumers can be configured to receive messages using an offset via the `x-stream-offset` argument. e.g.
+
+```js
+channel.consume(queue, onMessage, {
+  noAck: false,
+  arguments: {
+    'x-stream-offset': 'first'
+  }
+});
+```
+
+RabbitMQ supports six different types of offset, however specifying them can be
+
+| Offset Type | Example Value                                          | Notes |
+|-----------|----------------------------------------------------------|-------|
+| First     | `{'x-stream-offset':'first'}`                            | Start from the first message in the log |
+| Last      | `{'x-stream-offset':'last'}`                             | Start from the last "chunk" of messages (could be multiple messages) |
+| Next      | `{'x-stream-offset':'next'}`                             | Start from the next message (the default) |
+| Offset    | `{'x-stream-offset':5}`                                  | a numerical value specifying an exact offset to attach to the log at |
+| Timestamp | `{'x-stream-offset':{'!':'timestamp',value:1686519750}}` | a timestamp value specifying the point in time to attach to the log at. The timestamp must be the number of seconds since 00:00:00 UTC, 1970-01-01. Consumers can receive messages published a bit before the specified timestamp. |
+| Interval  | `{'x-stream-offset':'1h'}`                               | the time interval relative to current time to attach the log at. Valid units are Y, M, D, h, m and s |
+
+
+See https://www.rabbitmq.com/streams.html#consuming for more details

package/examples/stream_queues/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "stream_queues",
+  "version": "1.0.0",
+  "description": "An example demonstrating use of stream queues",
+  "main": "n",
+  "dependencies": {
+    "amqplib": "^0.10.3"
+  },
+  "devDependencies": {},
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "license": "ISC"
+}

package/examples/stream_queues/receive_stream.js

@@ -0,0 +1,55 @@
+const amqp = require('amqplib');
+
+(async () => {
+    try {
+        const connection = await amqp.connect('amqp://localhost');
+        process.once('SIGINT', connection.close);
+
+        const channel = await connection.createChannel();
+        const queue = 'my_first_stream';
+
+        // Define the queue stream
+        // Mandatory: exclusive: false, durable: true  autoDelete: false
+        await channel.assertQueue(queue, {
+            exclusive: false,
+            durable: true,
+            autoDelete: false,
+            arguments: {
+                'x-queue-type': 'stream',  // Mandatory to define stream queue
+                'x-max-length-bytes': 2_000_000_000  // Set the queue retention to 2GB else the stream doesn't have any limit
+            }
+        });
+
+        channel.qos(100);  // This is mandatory
+
+        channel.consume(queue, (msg) => {
+            console.log(" [x] Received '%s'", msg.content.toString());
+            channel.ack(msg);  // Mandatory
+        }, {
+            noAck: false,
+            arguments: {
+                /*
+                    Here you can specify the offset: : first, last, next, offset, timestamp and interval, i.e.
+
+                    'x-stream-offset': 'first'
+                    'x-stream-offset': 'last'
+                    'x-stream-offset': 'next'
+                    'x-stream-offset': 5
+                    'x-stream-offset': { '!': 'timestamp', value: 1686519750 }
+                    'x-stream-offset': '1h'
+
+                    The timestamp must be the desired number of seconds since 00:00:00 UTC, 1970-01-01
+                    The interval units can be Y, M, D, h, m, s
+
+                */
+                'x-stream-offset': 'first'
+            }
+        });
+
+        console.log(' [*] Waiting for messages. To exit press CTRL+C');
+    }
+    // Catch and display any errors in the console
+    catch(e) {
+        console.log(e)
+    }
+})();

package/examples/stream_queues/send_stream.js

@@ -0,0 +1,38 @@
+const amqp = require('amqplib');
+
+
+(async () => {
+    try {
+        const connection = await amqp.connect('amqp://localhost');
+        process.once('SIGINT', connection.close);
+
+        const channel = await connection.createChannel();
+        const queue = 'my_first_stream';
+        const msg = `Hello World! ${Date.now()}`;
+
+        // Define the queue stream
+        // Mandatory: exclusive: false, durable: true  autoDelete: false
+        await channel.assertQueue(queue, {
+            exclusive: false,
+            durable: true,
+            autoDelete: false,
+            arguments: {
+                'x-queue-type': 'stream',  // Mandatory to define stream queue
+                'x-max-length-bytes': 2_000_000_000  // Set the queue retention to 2GB else the stream doesn't have any limit
+            }
+        });
+
+        // Send the message to the stream queue
+        await channel.sendToQueue(queue, Buffer.from(msg));
+        console.log(" [x] Sent '%s'", msg);
+        await channel.close();
+
+        // Close connection
+        connection.close();
+    }
+    // Catch and display any errors in the console
+    catch(e) {
+        console.log(e)
+    }
+})();
+

package/examples/tutorials/callback_api/emit_log.js

@@ -1,28 +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 exchange = 'logs';
+const text = process.argv.slice(2).join(' ') || 'info: Hello World!';
 
-  var ex = 'logs';
+amqp.connect((err, connection) => {
+  if (err) return bail(err);
+  connection.createChannel((err, channel) => {
+    if (err) return bail(err, connection);
+    channel.assertExchange(exchange, 'fanout', { durable: false }, (err) => {
+      if (err) return bail(err, connection);
+      channel.publish(exchange, '', Buffer.from(text));
+      console.log(" [x] Sent '%s'", text);
+      channel.close(() => {
+        connection.close();
+      });
+    });
+  });
+});
 
-  function on_channel_open(err, ch) {
-    if (err !== null) return bail(err, conn);
-    ch.assertExchange(ex, 'fanout', {durable: false});
-    var msg = process.argv.slice(2).join(' ') ||
-      'info: Hello World!';
-    ch.publish(ex, '', Buffer.from(msg));
-    console.log(" [x] Sent '%s'", msg);
-    ch.close(function() { conn.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/emit_log_direct.js

@@ -1,30 +1,30 @@
 #!/usr/bin/env node
 
-var amqp = require('amqplib/callback_api');
+const amqp = require('amqplib/callback_api');
 
-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!';
 
-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);
-
-  var ex = 'direct_logs';
-  var exopts = {durable: false};
-  
-  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, Buffer.from(message));
-      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.assertExchange(exchange, 'direct', { durable: false }, (err) => {
+      if (err) return bail(err, connection);
+      channel.publish(exchange, routingKey, Buffer.from(text));
+      console.log(" [x] Sent '%s'", text);
+      channel.close(() => {
+        connection.close();
+      });
     });
-  }
-  conn.createChannel(on_channel_open);
-}
+  });
+});
 
-amqp.connect(on_connect);
+function bail(err, connection) {
+  console.error(err);
+  if (connection) connection.close(() => {
+    process.exit(1);
+  });
+}

package/examples/tutorials/callback_api/emit_log_topic.js

@@ -1,27 +1,30 @@
 #!/usr/bin/env node
 
-var amqp = require('amqplib/callback_api');
+const amqp = require('amqplib/callback_api');
 
-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 routingKey = (args.length > 0) ? args[0] : 'info';
+const text = args.slice(1).join(' ') || 'Hello World!';
 
-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);
-  var ex = 'topic_logs', exopts = {durable: false};
-  conn.createChannel(function(err, ch) {
-    ch.assertExchange(ex, 'topic', exopts, function(err, ok) {
-      if (err !== null) return bail(err, conn);
-      ch.publish(ex, key, Buffer.from(message));
-      console.log(" [x] Sent %s:'%s'", key, message);
-      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.assertExchange(exchange, 'topic', { durable: false }, (err) => {
+      if (err) return bail(err, connection);
+      channel.publish(exchange, routingKey, Buffer.from(text));
+      console.log(" [x] Sent '%s'", text);
+      channel.close(() => {
+        connection.close();
+      });
     });
   });
-}
+});
 
-amqp.connect(on_connect);
+function bail(err, connection) {
+  console.error(err);
+  if (connection) connection.close(() => {
+    process.exit(1);
+  });
+}

package/examples/tutorials/callback_api/new_task.js

@@ -1,27 +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); });
-}
+const queue = 'task_queue';
+const text = process.argv.slice(2).join(' ') || "Hello World!";
 
-function on_connect(err, conn) {
-  if (err !== null) return bail(err);
-
-  var q = 'task_queue';
-  
-  conn.createChannel(function(err, ch) {
-    if (err !== null) return bail(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, Buffer.from(msg), {persistent: true});
-      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: true }, (err) => {
+      if (err) return bails(err, connection);
+      channel.sendToQueue(queue, Buffer.from(text), { persistent: true });
+      console.log(" [x] Sent '%s'", text);
+      channel.close(() => {
+        connection.close();
+      });
     });
   });
-}
+});
 
-amqp.connect(on_connect);
+function bail(err, connection) {
+  console.error(err);
+  if (connection) connection.close(() => {
+    process.exit(1);
+  });
+}

package/examples/tutorials/callback_api/receive.js

@@ -1,30 +1,36 @@
 #!/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 = 'hello';
 
-function on_connect(err, conn) {
-  if (err !== null) return bail(err);
-  process.once('SIGINT', function() { conn.close(); });
-  
-  var q = 'hello';
+amqp.connect((err, connection) => {
+  if (err) return bail(err);
+  connection.createChannel((err, channel) => {
+    if (err) return bail(err, connection);
 
-  function on_channel_open(err, ch) {
-    ch.assertQueue(q, {durable: false}, function(err, ok) {
-      if (err !== null) return bail(err, conn);
-      ch.consume(q, function(msg) { // message callback
-        console.log(" [x] Received '%s'", msg.content.toString());
-      }, {noAck: true}, function(_consumeOk) { // consume callback
-        console.log(' [*] Waiting for messages. To exit press CTRL+C');
+    process.once('SIGINT', () => {
+      channel.close(() => {
+        connection.close();
       });
     });
-  }
 
-  conn.createChannel(on_channel_open);
-}
+    channel.assertQueue(queue, { durable: false }, (err) => {
+      if (err) return bail(err, connection);
+      channel.consume(queue, (message) => {
+        if (message) console.log(" [x] Received '%s'", message.content.toString());
+        else console.warn(' [x] Consumer cancelled');
+      }, { noAck: true }, (err) => {
+        if (err) return bail(err, connection);
+        console.log(" [*] Waiting for logs. To exit press CTRL+C.");
+      });
+    });
+  });
+});
 
-amqp.connect(on_connect);
+function bail(err, connection) {
+  console.error(err);
+  if (connection) connection.close(() => {
+    process.exit(1);
+  });
+}

package/examples/tutorials/callback_api/receive_logs.js

@@ -1,36 +1,42 @@
 #!/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 exchange = 'logs';
 
-function on_connect(err, conn) {
-  if (err !== null) return bail(err);
-  process.once('SIGINT', function() { conn.close(); });
+amqp.connect((err, connection) => {
+  if (err) return bail(err);
+  connection.createChannel((err, channel) => {
+    if (err) return bail(err, connection);
 
-  var ex = 'logs';
-  
-  function on_channel_open(err, ch) {
-    if (err !== null) return bail(err, conn);
-    ch.assertQueue('', {exclusive: true}, function(err, ok) {
-      var q = ok.queue;
-      ch.bindQueue(q, ex, '');
-      ch.consume(q, logMessage, {noAck: true}, function(err, ok) {
-        if (err !== null) return bail(err, conn);
-        console.log(" [*] Waiting for logs. To exit press CTRL+C.");
+    process.once('SIGINT', () => {
+      channel.close(() => {
+        connection.close();
       });
     });
-  }
 
-  function logMessage(msg) {
-    if (msg)
-      console.log(" [x] '%s'", msg.content.toString());
-  }
+    channel.assertExchange(exchange, 'fanout', { durable: false }, (err, { queue }) => {
+      if (err) return bail(err, connection);
+      channel.assertQueue('', { exclusive: true }, (err, { queue }) => {
+        if (err) return bail(err, connection);
+        channel.bindQueue(queue, exchange, '', {}, (err) => {
+          if (err) return bail(err, connection);
+          channel.consume(queue, (message) => {
+            if (message) console.log(" [x] '%s'", message.content.toString());
+            else console.warn(' [x] Consumer cancelled');
+          }, { noAck: true }, (err) => {
+            if (err) return bail(err, connection);
+            console.log(" [*] Waiting for logs. To exit press CTRL+C.");
+          });
+        });
+      });
+    });
+  });
+});
 
-  conn.createChannel(on_channel_open);
+function bail(err, connection) {
+  console.error(err);
+  if (connection) connection.close(() => {
+    process.exit(1);
+  });
 }
-
-amqp.connect(on_connect);