typespeed 2.0.13 → 2.0.16

package/test/node_modules/amqplib/callback_api.js

@@ -0,0 +1,22 @@
+var raw_connect = require('./lib/connect').connect;
+var CallbackModel = require('./lib/callback_model').CallbackModel;
+
+// Supports three shapes:
+// connect(url, options, callback)
+// connect(url, callback)
+// connect(callback)
+function connect(url, options, cb) {
+  if (typeof url === 'function')
+    cb = url, url = false, options = false;
+  else if (typeof options === 'function')
+    cb = options, options = false;
+
+  raw_connect(url, options, function(err, c) {
+    if (err === null) cb(null, new CallbackModel(c));
+    else cb(err);
+  });
+};
+
+module.exports.connect = connect;
+module.exports.credentials = require('./lib/credentials');
+module.exports.IllegalOperationError = require('./lib/error').IllegalOperationError;

package/test/node_modules/amqplib/channel_api.js

@@ -0,0 +1,16 @@
+var raw_connect = require('./lib/connect').connect;
+var ChannelModel = require('./lib/channel_model').ChannelModel;
+var promisify = require('util').promisify;
+
+function connect(url, connOptions) {
+  return promisify(function(cb) {
+    return raw_connect(url, connOptions, cb);
+  })()
+  .then(function(conn) {
+    return new ChannelModel(conn);
+  });
+};
+
+module.exports.connect = connect;
+module.exports.credentials = require('./lib/credentials');
+module.exports.IllegalOperationError = require('./lib/error').IllegalOperationError;

package/test/node_modules/amqplib/examples/headers.js

@@ -0,0 +1,42 @@
+#!/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);
+      });
+    });
+  });
+}
+
+function bindAndConsume(ch, ex, q) {
+  // When using a headers exchange, the headers to be matched go in
+  // the binding arguments. The routing key is ignore, so best left
+  // empty.
+
+  // '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'}});
+}

package/test/node_modules/amqplib/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/test/node_modules/amqplib/examples/send_generators.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+
+'use strict';
+
+// NB this requires the module 'co':
+//    npm install co
+const co = require('co');
+const amqp = require('amqplib');
+
+co(function* () {
+  // connection errors are handled in the co .catch handler
+  const conn = yield amqp.connect('amqp://localhost');
+
+  // try catch will throw any errors from the yielding the following promises to the co .catch handler
+  try {
+    const q = 'hello';
+    const msg = 'Hello World!';
+
+    // use a confirm channel so we can check the message is sent OK.
+    const channel = yield conn.createConfirmChannel();
+
+    yield channel.assertQueue(q);
+
+    channel.sendToQueue(q, Buffer.from(msg));
+
+    // if message has been nacked, this will result in an error (rejected promise);
+    yield channel.waitForConfirms();
+
+    console.log(" [x] Sent '%s'", msg);
+
+    channel.close();
+  }
+  catch (e) {
+    throw e;
+  }
+  finally {
+    conn.close();
+  }
+
+}).catch(err => {
+  console.warn('Error:', err);
+});

package/test/node_modules/amqplib/examples/ssl.js

@@ -0,0 +1,64 @@
+// Example of using a TLS/SSL connection. Note that the server must be
+// configured to accept SSL connections; see, for example,
+// http://www.rabbitmq.com/ssl.html.
+//
+// When trying this out, I followed the RabbitMQ SSL guide above,
+// almost verbatim. I set the CN of the server certificate to
+// 'localhost' rather than $(hostname) (since on my MBP hostname ends
+// up being "<blah>.local", which is just weird). My client
+// certificates etc., are in `../etc/client/`. My testca certificate
+// is in `../etc/testca` and server certs etc., in `../etc/server`,
+// and I've made a `rabbitmq.config` file, with which I start
+// RabbitMQ:
+//
+//     RABBITMQ_CONFIG_FILE=`pwd`/../etc/server/rabbitmq \
+//       /usr/local/sbin/rabbitmq-server &
+//
+// A way to check RabbitMQ's running with SSL OK is to use
+//
+//     openssl s_client -connect localhost:5671
+
+var amqp = require('../');
+var fs = require('fs');
+
+// Assemble the SSL options; for verification we need at least
+// * a certificate to present to the server ('cert', in PEM format)
+// * the private key for the certificate ('key', in PEM format)
+// * (possibly) a passphrase for the private key
+//
+// The first two may be replaced with a PKCS12 file ('pfx', in pkcs12
+// format)
+
+// We will also want to list the CA certificates that we will trust,
+// since we're using a self-signed certificate. It is NOT recommended
+// to use `rejectUnauthorized: false`.
+
+// Options for full client and server verification:
+var opts = {
+  cert: fs.readFileSync('../etc/client/cert.pem'),
+  key: fs.readFileSync('../etc/client/key.pem'),
+  // cert and key or
+  // pfx: fs.readFileSync('../etc/client/keycert.p12'),
+  passphrase: 'MySecretPassword',
+  ca: [fs.readFileSync('../etc/testca/cacert.pem')]
+};
+
+// Options for just confidentiality. This requires RabbitMQ's SSL
+// configuration to include the items
+//
+//     {verify, verify_none},
+//     {fail_if_no_peer_cert,false}
+//
+// var 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);
+
+open.then(function(conn) {
+  process.on('SIGINT', conn.close.bind(conn));
+  return conn.createChannel().then(function(ch) {
+    ch.sendToQueue('foo', Buffer.from('Hello World!'));
+  });
+}).then(null, console.warn);

package/test/node_modules/amqplib/examples/tutorials/README.md

@@ -0,0 +1,93 @@
+# RabbitMQ tutorials
+
+This directory contains the [RabbitMQ tutorials][rabbitmq-tutes],
+ported to amqplib. The sub-directory `callback_api` has translations
+of the tutorial programs to the callback-oriented API.
+
+## Preparation
+
+To run the tutorial code, you need amqplib installed. Assuming you are
+in a clone of the amqplib repository, from the tutorials directory:
+
+    npm install
+
+or to use the latest released version,
+
+    npm install amqplib
+
+Then just run each file as a script, e.g., in bash
+
+    ./send.js
+
+or
+
+    node send.js
+
+or
+
+    nave use 0.8 node send.js
+
+## [Tutorial one: Hello World!][tute-one]
+
+A "Hello World" example, with one script sending a message to a queue,
+and another receiving messages from the same queue.
+
+ * [send.js](send.js)
+ * [receive.js](receive.js)
+
+## [Tutorial two: Work queues][tute-two]
+
+Using RabbitMQ as a work queue; `new_task` creates a task, and
+`worker` processes tasks. Multiple `worker` process will share the
+tasks among them. Long-running tasks are simulated by supplying a
+string with dots, e.g., '...' to `new_task`. Each dot makes the worker
+"work" for a second.
+
+ * [new_task.js](new_task.js)
+ * [worker.js](worker.js)
+
+## [Tutorial three: Publish/Subscribe][tute-three]
+
+Using RabbitMQ as a broadcast mechanism. `emit_log` sends a "log"
+message to a fanout exchange, and all `receive_logs` processes receive
+log messages.
+
+ * [emit_log.js](emit_log.js)
+ * [receive_logs.js](receive_logs.js)
+
+## [Tutorial four: Routing][tute-four]
+
+Using RabbitMQ as a routing ('somecast') mechanism. `emit_log_direct`
+sends a log message with a severity, and all `receive_logs_direct`
+processes receive log messages for the severities on which they are
+listening.
+
+ * [emit_log_direct.js](emit_log_direct.js)
+ * [receive_logs_direct.js](receive_logs_direct.js)
+
+## [Tutorial five: Topics][tute-five]
+
+Extends the previous tutorial to routing with wildcarded patterns.
+
+ * [emit_log_topic.js](emit_log_topic.js)
+ * [receive_logs_topic.js](receive_logs_topic.js)
+
+## [Tutorial six: RPC][tute-six]
+
+Using RabbitMQ as an RPC intermediary, queueing requests for servers
+and routing replies back to clients.
+
+ * [rpc_server.js](rpc_server.js)
+ * [rpc_client.js](rpc_client.js)
+
+I depart slightly from the original tutorial code, which I think has
+some needless object-orientation (in the Python code; you don't get a
+choice about needless object-orientation in Java).
+
+[rabbitmq-tutes]: http://github.com/rabbitmq/rabbitmq-tutorials
+[tute-one]: http://www.rabbitmq.com/tutorials/tutorial-one-javascript.html
+[tute-two]: http://www.rabbitmq.com/tutorials/tutorial-two-javascript.html
+[tute-three]: http://www.rabbitmq.com/tutorials/tutorial-three-javascript.html
+[tute-four]: http://www.rabbitmq.com/tutorials/tutorial-four-javascript.html
+[tute-five]: http://www.rabbitmq.com/tutorials/tutorial-five-javascript.html
+[tute-six]: http://www.rabbitmq.com/tutorials/tutorial-six-javascript.html

package/test/node_modules/amqplib/examples/tutorials/callback_api/emit_log.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+var 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);
+
+  var ex = 'logs';
+
+  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);
+}
+
+amqp.connect(on_connect);

package/test/node_modules/amqplib/examples/tutorials/callback_api/emit_log_direct.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+var 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!';
+
+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(); });
+    });
+  }
+  conn.createChannel(on_channel_open);
+}
+
+amqp.connect(on_connect);

package/test/node_modules/amqplib/examples/tutorials/callback_api/emit_log_topic.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+var 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!';
+
+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(on_connect);

package/test/node_modules/amqplib/examples/tutorials/callback_api/new_task.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+var 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);
+
+  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(on_connect);

package/test/node_modules/amqplib/examples/tutorials/callback_api/receive.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+var 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);
+  process.once('SIGINT', function() { conn.close(); });
+  
+  var q = 'hello';
+
+  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');
+      });
+    });
+  }
+
+  conn.createChannel(on_channel_open);
+}
+
+amqp.connect(on_connect);

package/test/node_modules/amqplib/examples/tutorials/callback_api/receive_logs.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+var 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);
+  process.once('SIGINT', function() { conn.close(); });
+
+  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.");
+      });
+    });
+  }
+
+  function logMessage(msg) {
+    if (msg)
+      console.log(" [x] '%s'", msg.content.toString());
+  }
+
+  conn.createChannel(on_channel_open);
+}
+
+amqp.connect(on_connect);

package/test/node_modules/amqplib/examples/tutorials/callback_api/receive_logs_direct.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+
+var amqp = require('amqplib/callback_api');
+
+var basename = require('path').basename;
+
+var 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 = '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;
+
+      function sub(err) {
+        if (err !== null) return bail(err, conn);
+        else if (i < severities.length) {
+          ch.bindQueue(queue, ex, severities[i], {}, sub);
+          i++;
+        }
+      }
+
+      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);
+      });
+    });
+  });
+}
+
+function logMessage(msg) {
+  console.log(" [x] %s:'%s'",
+              msg.fields.routingKey,
+              msg.content.toString());
+}
+
+amqp.connect(on_connect);

package/test/node_modules/amqplib/examples/tutorials/callback_api/receive_logs_topic.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+var amqp = require('amqplib/callback_api');
+var basename = require('path').basename;
+
+var keys = process.argv.slice(2);
+if (keys.length < 1) {
+  console.log('Usage %s pattern [pattern...]',
+              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;
+
+      function sub(err) {
+        if (err !== null) return bail(err, conn);
+        else if (i < keys.length) {
+          ch.bindQueue(queue, ex, keys[i], {}, sub);
+          i++;
+        }
+      }
+
+      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);
+      });
+    });
+  });
+}
+
+function logMessage(msg) {
+  console.log(" [x] %s:'%s'",
+              msg.fields.routingKey,
+              msg.content.toString());
+}
+
+amqp.connect(on_connect);

package/test/node_modules/amqplib/examples/tutorials/callback_api/rpc_client.js

@@ -0,0 +1,49 @@
+#!/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);
+  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); });
+}
+
+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
+      });
+    });
+  });
+}
+
+amqp.connect(on_connect);