rascal 13.1.3 → 14.2.0

package/examples/advanced/cluster.js

@@ -1,12 +1,12 @@
-var Rascal = require("../..");
-var cluster = require("cluster");
+var Rascal = require('../..');
+var cluster = require('cluster');
 
 if (cluster.isMaster) {
   Rascal.counters.inMemoryCluster.master();
   cluster.fork();
-  cluster.on("exit", function () {
+  cluster.on('exit', function () {
     cluster.fork();
   });
 } else {
-  require("./index");
+  require('./index');
 }

package/examples/advanced/config.js

@@ -2,7 +2,7 @@ module.exports = {
   rascal: {
     vhosts: {
       // Define the name of the vhost
-      "customer-vhost": {
+      'customer-vhost': {
         // Creates the vhost if it doesn't exist (requires the RabbitMQ management plugin to be installed)
         assert: true,
 
@@ -10,11 +10,11 @@ module.exports = {
         // Rascal will randomise the list, and cycle through the entries until it finds one that works
         connections: [
           {
-            url: "amqp://does-not-exist-1b9935d9-5066-4b13-84dc-a8e2bb618154:5672/customer-vhost",
+            url: 'amqp://does-not-exist-1b9935d9-5066-4b13-84dc-a8e2bb618154:5672/customer-vhost',
           },
           {
-            user: "guest",
-            password: "guest",
+            user: 'guest',
+            password: 'guest',
             port: 5672,
             options: {
               heartbeat: 1,
@@ -27,94 +27,89 @@ module.exports = {
 
         // Define exchanges within the registration vhost
         exchanges: [
-          "service", // Shared exchange for all services within this vhost
-          "delay", // To delay failed messages before a retry
-          "retry", // To retry failed messages up to maximum number of times
-          "dead_letters", // When retrying fails, messages end up here
+          'service', // Shared exchange for all services within this vhost
+          'delay', // To delay failed messages before a retry
+          'retry', // To retry failed messages up to maximum number of times
+          'dead_letters', // When retrying fails, messages end up here
         ],
 
         // Define queues within the registration vhost
         // A good naming convention for queues is consumer:entity:action
         queues: {
           // Create a queue for saving users
-          "registration_service:user:save": {
+          'registration_service:user:save': {
             options: {
               arguments: {
                 // Route nacked messages to a service specific dead letter queue
-                "x-dead-letter-exchange": "dead_letters",
-                "x-dead-letter-routing-key": "registration_service.dead_letter",
+                'x-dead-letter-exchange': 'dead_letters',
+                'x-dead-letter-routing-key': 'registration_service.dead_letter',
               },
             },
           },
 
           // Create a queue for deleting users
-          "registration_service:user:delete": {
+          'registration_service:user:delete': {
             options: {
               arguments: {
                 // Route nacked messages to a service specific dead letter queue
-                "x-dead-letter-exchange": "dead_letters",
-                "x-dead-letter-routing-key": "registration_service.dead_letter",
+                'x-dead-letter-exchange': 'dead_letters',
+                'x-dead-letter-routing-key': 'registration_service.dead_letter',
               },
             },
           },
 
           // Create a delay queue to hold failed messages for a short interval before retrying
-          "delay:1m": {
+          'delay:1m': {
             options: {
               arguments: {
                 // Configure messages to expire after 1 minute, then route them to the retry exchange
-                "x-message-ttl": 60000,
-                "x-dead-letter-exchange": "retry",
+                'x-message-ttl': 60000,
+                'x-dead-letter-exchange': 'retry',
               },
             },
           },
 
           // Queue for holding dead letters until they can be resolved
-          "dead_letters:registration_service": {},
+          'dead_letters:registration_service': {},
         },
 
         // Bind the queues to the exchanges.
         // A good naming convention for routing keys is producer.entity.event
         bindings: {
           // Route create/update user messages to the save queue
-          "service[registration_webapp.user.created.#,registration_webapp.user.updated.#] -> registration_service:user:save":
-            {},
+          'service[registration_webapp.user.created.#,registration_webapp.user.updated.#] -> registration_service:user:save': {},
 
           // Route delete user messages to the delete queue
-          "service[registration_webapp.user.deleted.#] -> registration_service:user:delete":
-            {},
+          'service[registration_webapp.user.deleted.#] -> registration_service:user:delete': {},
 
           // Route delayed messages to the 1 minute delay queue
-          "delay[delay.1m] -> delay:1m": {},
+          'delay[delay.1m] -> delay:1m': {},
 
           // Route retried messages back to their original queue using the CC routing keys set by Rascal
-          "retry[registration_service:user:save.#] -> registration_service:user:save":
-            {},
-          "retry[registration_service:user:delete.#] -> registration_service:user:delete":
-            {},
+          'retry[registration_service:user:save.#] -> registration_service:user:save': {},
+          'retry[registration_service:user:delete.#] -> registration_service:user:delete': {},
 
           // Route dead letters the service specific dead letter queue
-          "dead_letters[registration_service.dead_letter] -> dead_letters:registration_service":
-            {},
+          'dead_letters[registration_service.dead_letter] -> dead_letters:registration_service': {},
         },
 
         // Setup subscriptions
         subscriptions: {
           save_user: {
-            queue: "registration_service:user:save",
-            handler: "saveUser.js",
+            queue: 'registration_service:user:save',
+            handler: 'saveUser.js',
             redeliveries: {
               limit: 5,
-              counter: "shared",
+              counter: 'shared',
             },
           },
 
           delete_user: {
-            queue: "registration_service:user:delete",
-            handler: "deleteUser.js",
+            queue: 'registration_service:user:delete',
+            handler: 'deleteUser.js',
             redeliveries: {
               limit: 5,
-              counter: "shared",
+              counter: 'shared',
             },
           },
         },
@@ -123,29 +118,29 @@ module.exports = {
         publications: {
           // Always publish a notification of success (it's useful for testing if nothing else)
           save_user_succeeded: {
-            exchange: "service",
+            exchange: 'service',
           },
           delete_user_succeeded: {
-            exchange: "service",
-            encryption: "well-known-v1",
+            exchange: 'service',
+            encryption: 'well-known-v1',
           },
 
           // Forward messages to the 1 minute delay queue when retrying
           retry_in_1m: {
-            exchange: "delay",
+            exchange: 'delay',
             options: {
-              CC: ["delay.1m"],
+              CC: ['delay.1m'],
             },
           },
 
           // Publication for generating user create, update and delete messages
           // This would probably be the job of another application (e.g. a web application)
           user_event: {
-            exchange: "service",
+            exchange: 'service',
             // Specifying an encryption profile in the publication will cause the message content to be encrypted
             // The profile name and iv are added as headers, and used to automatically decrypt messages,
             // providing the consumer configuration has a matching profile.
-            encryption: "well-known-v1",
+            encryption: 'well-known-v1',
           },
         },
 
@@ -166,13 +161,13 @@ module.exports = {
       // Deferred retry is a good strategy for temporary (connection timeout) or unknown errors
       deferred_retry: [
         {
-          strategy: "forward",
+          strategy: 'forward',
           attempts: 10,
-          publication: "retry_in_1m",
+          publication: 'retry_in_1m',
           xDeathFix: true, // See https://github.com/rabbitmq/rabbitmq-server/issues/161
         },
         {
-          strategy: "nack",
+          strategy: 'nack',
         },
       ],
 
@@ -181,7 +176,7 @@ module.exports = {
       // causing it to be routed to the services dead letter queue
       dead_letter: [
         {
-          strategy: "republish",
+          strategy: 'republish',
           immediateNack: true,
         },
       ],
@@ -191,16 +186,16 @@ module.exports = {
       counters: {
         shared: {
           size: 10,
-          type: "inMemoryCluster",
+          type: 'inMemoryCluster',
         },
       },
     },
     // Define encryption profiles
     encryption: {
-      "well-known-v1": {
-        key: "f81db52a3b2c717fe65d9a3b7dd04d2a08793e1a28e3083db3ea08db56e7c315",
+      'well-known-v1': {
+        key: 'f81db52a3b2c717fe65d9a3b7dd04d2a08793e1a28e3083db3ea08db56e7c315',
         ivLength: 16,
-        algorithm: "aes-256-cbc",
+        algorithm: 'aes-256-cbc',
       },
     },
   },

package/examples/advanced/handlers/deleteUser.js

@@ -1,26 +1,19 @@
-var chalk = require("chalk");
-var format = require("util").format;
+var chalk = require('chalk');
+var format = require('util').format;
 
 module.exports = function (broker) {
   return function (user, cb) {
     // Pretend we'd really asynchronously deleted something
     setImmediate(function () {
-      console.log(chalk.cyan("Deleting user:"), user.username);
+      console.log(chalk.cyan('Deleting user:'), user.username);
 
-      if (user.crash) throw new Error("Crashing on user: " + user.username);
+      if (user.crash) throw new Error('Crashing on user: ' + user.username);
 
-      var routingKey = format(
-        "registration_service.user.deleted.%s",
-        user.username
-      );
-      broker.publish(
-        "delete_user_succeeded",
-        routingKey,
-        function (err, publication) {
-          if (err) return cb(err);
-          publication.on("success", () => cb).on("error", console.error);
-        }
-      );
+      var routingKey = format('registration_service.user.deleted.%s', user.username);
+      broker.publish('delete_user_succeeded', routingKey, function (err, publication) {
+        if (err) return cb(err);
+        publication.on('success', () => cb).on('error', console.error);
+      });
     });
   };
 };

package/examples/advanced/handlers/saveUser.js

@@ -1,40 +1,33 @@
-var chalk = require("chalk");
-var format = require("util").format;
+var chalk = require('chalk');
+var format = require('util').format;
 
 module.exports = function (broker) {
   return function (user, cb) {
     // Pretend we'd really asynchronously saved something
     setImmediate(function () {
-      console.log(chalk.magenta("Saving user:"), user.username);
+      console.log(chalk.magenta('Saving user:'), user.username);
 
-      if (user.crash) throw new Error("Crashing on user: " + user.username);
+      if (user.crash) throw new Error('Crashing on user: ' + user.username);
 
       // Simulate errors and success
       var err;
       switch (Math.floor(Math.random() * 10)) {
         case 5: {
-          err = new Error("Connection Timeout");
+          err = new Error('Connection Timeout');
           err.recoverable = true;
           return cb(err);
         }
         case 7: {
-          err = new Error("Duplicate Key Violation");
+          err = new Error('Duplicate Key Violation');
           err.recoverable = false;
           return cb(err);
         }
         default: {
-          var routingKey = format(
-            "registration_service.user.saved.%s",
-            user.username
-          );
-          broker.publish(
-            "save_user_succeeded",
-            routingKey,
-            function (err, publication) {
-              if (err) return cb(err);
-              publication.on("success", () => cb).on("error", console.error);
-            }
-          );
+          var routingKey = format('registration_service.user.saved.%s', user.username);
+          broker.publish('save_user_succeeded', routingKey, function (err, publication) {
+            if (err) return cb(err);
+            publication.on('success', () => cb).on('error', console.error);
+          });
         }
       }
     });

package/examples/advanced/index.js

@@ -1,117 +1,95 @@
-var Rascal = require("../..");
-var config = require("./config");
-var _ = require("lodash");
-var Chance = require("Chance");
+var Rascal = require('../..');
+var config = require('./config');
+var _ = require('lodash');
+var Chance = require('Chance');
 var chance = new Chance();
-var format = require("util").format;
+var format = require('util').format;
 
-Rascal.Broker.create(
-  Rascal.withDefaultConfig(config.rascal),
-  function (err, broker) {
-    if (err) bail(err);
+Rascal.Broker.create(Rascal.withDefaultConfig(config.rascal), function (err, broker) {
+  if (err) bail(err);
 
-    broker.on("error", function (err) {
-      console.error(err.message);
-    });
+  broker.on('error', function (err) {
+    console.error(err.message);
+  });
 
-    _.each(
-      broker.config.subscriptions,
-      function (subscriptionConfig, subscriptionName) {
-        if (!subscriptionConfig.handler) return;
+  _.each(broker.config.subscriptions, function (subscriptionConfig, subscriptionName) {
+    if (!subscriptionConfig.handler) return;
 
-        var handler = require("./handlers/" + subscriptionConfig.handler)(
-          broker
-        );
+    var handler = require('./handlers/' + subscriptionConfig.handler)(broker);
 
-        broker.subscribe(subscriptionName, function (err, subscription) {
-          if (err) return bail(err);
-          subscription
-            .on("message", function (message, content, ackOrNack) {
-              handler(content, function (err) {
-                if (!err) return ackOrNack();
-                console.log(err);
-                ackOrNack(
-                  err,
-                  err.recoverable
-                    ? broker.config.recovery.deferred_retry
-                    : broker.config.recovery.dead_letter
-                );
-              });
-            })
-            .on("invalid_content", function (err, message, ackOrNack) {
-              console.error("Invalid Content", err.message);
-              ackOrNack(err, broker.config.recovery.dead_letter);
-            })
-            .on("redeliveries_exceeded", function (err, message, ackOrNack) {
-              console.error("Redeliveries Exceeded", err.message);
-              ackOrNack(err, broker.config.recovery.dead_letter);
-            })
-            .on("cancel", function (err) {
-              console.warn(err.message);
-            })
-            .on("error", function (err) {
-              console.error(err.message);
-            });
+    broker.subscribe(subscriptionName, function (err, subscription) {
+      if (err) return bail(err);
+      subscription
+        .on('message', function (message, content, ackOrNack) {
+          handler(content, function (err) {
+            if (!err) return ackOrNack();
+            console.log(err);
+            ackOrNack(err, err.recoverable ? broker.config.recovery.deferred_retry : broker.config.recovery.dead_letter);
+          });
+        })
+        .on('invalid_content', function (err, message, ackOrNack) {
+          console.error('Invalid Content', err.message);
+          ackOrNack(err, broker.config.recovery.dead_letter);
+        })
+        .on('redeliveries_exceeded', function (err, message, ackOrNack) {
+          console.error('Redeliveries Exceeded', err.message);
+          ackOrNack(err, broker.config.recovery.dead_letter);
+        })
+        .on('cancel', function (err) {
+          console.warn(err.message);
+        })
+        .on('error', function (err) {
+          console.error(err.message);
         });
-      }
-    );
-
-    // Simulate a web app handling user registrations
-    setInterval(function () {
-      var user = {
-        username: chance.first() + "_" + chance.last(),
-        crash: randomInt(10) === 10,
-      };
-      var events = { 1: "created", 2: "updated", 3: "deleted" };
-      var event = events[randomInt(3)];
-      var routingKey = format(
-        "registration_webapp.user.%s.%s",
-        event,
-        user.username
-      );
+    });
+  });
 
-      broker.publish(
-        "user_event",
-        user,
-        routingKey,
-        function (err, publication) {
-          if (err) return console.log(err.message);
-          publication
-            .on("success", function () {
-              // confirmed
-            })
-            .on("error", function (err) {
-              console.error(err.message);
-            });
-        }
-      );
-    }, 1000);
+  // Simulate a web app handling user registrations
+  setInterval(function () {
+    var user = {
+      username: chance.first() + '_' + chance.last(),
+      crash: randomInt(10) === 10,
+    };
+    var events = { 1: 'created', 2: 'updated', 3: 'deleted' };
+    var event = events[randomInt(3)];
+    var routingKey = format('registration_webapp.user.%s.%s', event, user.username);
 
-    process
-      .on("SIGINT", function () {
-        broker.shutdown(function () {
-          process.exit();
-        });
-      })
-      .on("SIGTERM", () => {
-        broker.shutdown(function () {
-          process.exit();
-        });
-      })
-      .on("unhandledRejection", (reason, p) => {
-        console.error(reason, "Unhandled Rejection at Promise", p);
-        broker.shutdown(function () {
-          process.exit(-1);
-        });
-      })
-      .on("uncaughtException", (err) => {
-        console.error(err, "Uncaught Exception thrown");
-        broker.shutdown(function () {
-          process.exit(-2);
+    broker.publish('user_event', user, routingKey, function (err, publication) {
+      if (err) return console.log(err.message);
+      publication
+        .on('success', function () {
+          // confirmed
+        })
+        .on('error', function (err) {
+          console.error(err.message);
         });
+    });
+  }, 1000);
+
+  process
+    .on('SIGINT', function () {
+      broker.shutdown(function () {
+        process.exit();
+      });
+    })
+    .on('SIGTERM', () => {
+      broker.shutdown(function () {
+        process.exit();
       });
-  }
-);
+    })
+    .on('unhandledRejection', (reason, p) => {
+      console.error(reason, 'Unhandled Rejection at Promise', p);
+      broker.shutdown(function () {
+        process.exit(-1);
+      });
+    })
+    .on('uncaughtException', (err) => {
+      console.error(err, 'Uncaught Exception thrown');
+      broker.shutdown(function () {
+        process.exit(-2);
+      });
+    });
+});
 
 function randomInt(max) {
   return Math.floor(Math.random() * max) + 1;

package/examples/busy-publisher/config.json

@@ -0,0 +1,40 @@
+{
+  "$schema": "../../lib/config/schema.json",
+  "vhosts": {
+    "/": {
+      "publicationChannelPools": {
+        "confirmPool": {
+          "max": 10,
+          "min": 10,
+          "evictionRunIntervalMillis": 1000,
+          "idleTimeoutMillis": 5000,
+          "autostart": true
+        }
+      },
+      "connection": {
+        "heartbeat": 5,
+        "socketOptions": {
+          "timeout": 1000
+        }
+      },
+      "exchanges": ["demo_ex"],
+      "queues": ["demo_q"],
+      "bindings": ["demo_ex[a.b.c] -> demo_q"],
+      "publications": {
+        "demo_pub": {
+          "exchange": "demo_ex",
+          "routingKey": "a.b.c",
+          "confirm": false,
+          "options": {
+            "persistent": false
+          }
+        }
+      },
+      "subscriptions": {
+        "demo_sub": {
+          "queue": "demo_q"
+        }
+      }
+    }
+  }
+}

package/examples/busy-publisher/index.js

@@ -1,38 +1,32 @@
-const Rascal = require("../..");
-const config = require("./config");
-const random = require("random-readable");
+const Rascal = require('../..');
+const config = require('./config');
+const random = require('random-readable');
 
 Rascal.Broker.create(Rascal.withDefaultConfig(config), (err, broker) => {
   if (err) throw err;
 
-  broker.on("error", console.error);
+  broker.on('error', console.error);
 
   const stream = random
     .createRandomStream()
-    .on("error", console.error)
-    .on("data", (data) => {
-      broker.publish("demo_pub", data, (err, publication) => {
+    .on('error', console.error)
+    .on('data', (data) => {
+      broker.publish('demo_pub', data, (err, publication) => {
         if (err) throw err;
-        publication.on("error", console.error);
+        publication.on('error', console.error);
       });
     })
-    .on("end", () => {
-      console.log("end");
+    .on('end', () => {
+      console.log('end');
     });
 
-  broker.on("busy", (details) => {
-    console.log(
-      Date.now(),
-      `Pausing vhost: ${details.vhost} (mode: ${details.mode}, queue: ${details.queue}, size: ${details.size}, borrowed: ${details.borrowed}, available: ${details.available})`
-    );
+  broker.on('busy', (details) => {
+    console.log(Date.now(), `Pausing vhost: ${details.vhost} (mode: ${details.mode}, queue: ${details.queue}, size: ${details.size}, borrowed: ${details.borrowed}, available: ${details.available})`);
     stream.pause();
   });
 
-  broker.on("ready", (details) => {
-    console.log(
-      Date.now(),
-      `Resuming vhost: ${details.vhost} (mode: ${details.mode}, queue: ${details.queue}, size: ${details.size}, borrowed: ${details.borrowed}, available: ${details.available})`
-    );
+  broker.on('ready', (details) => {
+    console.log(Date.now(), `Resuming vhost: ${details.vhost} (mode: ${details.mode}, queue: ${details.queue}, size: ${details.size}, borrowed: ${details.borrowed}, available: ${details.available})`);
     stream.resume();
   });
 });

package/examples/default-exchange/config.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "../../lib/config/schema.json",
+  "vhosts": {
+    "/": {
+      "connection": {
+        "heartbeat": 1,
+        "socketOptions": {
+          "timeout": 1000
+        }
+      },
+      "exchanges": [""],
+      "queues": ["demo_q"],
+      "publications": {
+        "demo_pub": {
+          "exchange": ""
+        }
+      },
+      "subscriptions": {
+        "demo_sub": {
+          "queue": "demo_q"
+        }
+      }
+    }
+  }
+}