flok 0.0.12 → 0.0.14

data/spec/iface/driver/assets/node_modules/socket.io/node_modules/socket.io-client/node_modules/engine.io-client/node_modules/ws/bench/parser.benchmark.js

@@ -0,0 +1,115 @@
+/*!
+ * ws: a node.js websocket client
+ * Copyright(c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+ * MIT Licensed
+ */
+
+/**
+ * Benchmark dependencies.
+ */
+
+var benchmark = require('benchmark')
+  , Receiver = require('../').Receiver
+  , suite = new benchmark.Suite('Receiver');
+require('tinycolor');
+require('./util');
+
+/**
+ * Setup receiver.
+ */
+ 
+suite.on('start', function () {
+  receiver = new Receiver();
+});
+
+suite.on('cycle', function () {
+  receiver = new Receiver();
+});
+
+/**
+ * Benchmarks.
+ */
+
+var pingMessage = 'Hello'
+  , pingPacket1 = getBufferFromHexString('89 ' + (pack(2, 0x80 | pingMessage.length)) + 
+                                         ' 34 83 a8 68 '+ getHexStringFromBuffer(mask(pingMessage, '34 83 a8 68')));
+suite.add('ping message', function () {
+  receiver.add(pingPacket1);  
+});
+
+var pingPacket2 = getBufferFromHexString('89 00')
+suite.add('ping with no data', function () {
+  receiver.add(pingPacket2);
+});
+
+var closePacket = getBufferFromHexString('88 00');
+suite.add('close message', function () {
+  receiver.add(closePacket);
+  receiver.endPacket();
+});
+
+var maskedTextPacket = getBufferFromHexString('81 93 34 83 a8 68 01 b9 92 52 4f a1 c6 09 59 e6 8a 52 16 e6 cb 00 5b a1 d5');
+suite.add('masked text message', function () {
+  receiver.add(maskedTextPacket);
+});
+
+binaryDataPacket = (function() {
+  var length = 125
+    , message = new Buffer(length)
+  for (var i = 0; i < length; ++i) message[i] = i % 10;
+  return getBufferFromHexString('82 ' + getHybiLengthAsHexString(length, true) + ' 34 83 a8 68 '
+       + getHexStringFromBuffer(mask(message), '34 83 a8 68'));
+})();
+suite.add('binary data (125 bytes)', function () {
+  try {
+    receiver.add(binaryDataPacket);
+    
+  }
+  catch(e) {console.log(e)}
+});
+
+binaryDataPacket2 = (function() {
+  var length = 65535
+    , message = new Buffer(length)
+  for (var i = 0; i < length; ++i) message[i] = i % 10;
+  return getBufferFromHexString('82 ' + getHybiLengthAsHexString(length, true) + ' 34 83 a8 68 '
+       + getHexStringFromBuffer(mask(message), '34 83 a8 68'));
+})();
+suite.add('binary data (65535 bytes)', function () {
+  receiver.add(binaryDataPacket2);
+});
+
+binaryDataPacket3 = (function() {
+  var length = 200*1024
+    , message = new Buffer(length)
+  for (var i = 0; i < length; ++i) message[i] = i % 10;
+  return getBufferFromHexString('82 ' + getHybiLengthAsHexString(length, true) + ' 34 83 a8 68 '
+       + getHexStringFromBuffer(mask(message), '34 83 a8 68'));
+})();
+suite.add('binary data (200 kB)', function () {
+  receiver.add(binaryDataPacket3);
+});
+
+/**
+ * Output progress.
+ */
+
+suite.on('cycle', function (bench, details) {
+  console.log('\n  ' + suite.name.grey, details.name.white.bold);
+  console.log('  ' + [
+      details.hz.toFixed(2).cyan + ' ops/sec'.grey
+    , details.count.toString().white + ' times executed'.grey
+    , 'benchmark took '.grey + details.times.elapsed.toString().white + ' sec.'.grey
+    , 
+  ].join(', '.grey));
+});
+
+/**
+ * Run/export benchmarks.
+ */
+
+if (!module.parent) {
+  suite.run();
+} else {
+  module.exports = suite;
+}

data/spec/iface/driver/assets/node_modules/socket.io/node_modules/socket.io-client/node_modules/engine.io-client/node_modules/ws/bench/sender.benchmark.js

@@ -0,0 +1,66 @@
+/*!
+ * ws: a node.js websocket client
+ * Copyright(c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+ * MIT Licensed
+ */
+
+/**
+ * Benchmark dependencies.
+ */
+
+var benchmark = require('benchmark')
+  , Sender = require('../').Sender
+  , suite = new benchmark.Suite('Sender');
+require('tinycolor');
+require('./util');
+
+/**
+ * Setup sender.
+ */
+ 
+suite.on('start', function () {
+  sender = new Sender();
+  sender._socket = { write: function() {} };
+});
+
+suite.on('cycle', function () {
+  sender = new Sender();
+  sender._socket = { write: function() {} };
+});
+
+/**
+ * Benchmarks
+ */
+
+framePacket = new Buffer(200*1024);
+framePacket.fill(99);
+suite.add('frameAndSend, unmasked (200 kB)', function () {
+  sender.frameAndSend(0x2, framePacket, true, false);
+});
+suite.add('frameAndSend, masked (200 kB)', function () {
+  sender.frameAndSend(0x2, framePacket, true, true);
+});
+
+/**
+ * Output progress.
+ */
+
+suite.on('cycle', function (bench, details) {
+  console.log('\n  ' + suite.name.grey, details.name.white.bold);
+  console.log('  ' + [
+      details.hz.toFixed(2).cyan + ' ops/sec'.grey
+    , details.count.toString().white + ' times executed'.grey
+    , 'benchmark took '.grey + details.times.elapsed.toString().white + ' sec.'.grey
+    , 
+  ].join(', '.grey));
+});
+
+/**
+ * Run/export benchmarks.
+ */
+
+if (!module.parent) {
+  suite.run();
+} else {
+  module.exports = suite;
+}

data/spec/iface/driver/assets/node_modules/socket.io/node_modules/socket.io-client/node_modules/engine.io-client/node_modules/ws/bench/speed.js

@@ -0,0 +1,105 @@
+var cluster = require('cluster')
+  , WebSocket = require('../')
+  , WebSocketServer = WebSocket.Server
+  , crypto = require('crypto')
+  , util = require('util')
+  , ansi = require('ansi');
+require('tinycolor');
+
+function roundPrec(num, prec) {
+  var mul = Math.pow(10, prec);
+  return Math.round(num * mul) / mul;
+}
+
+function humanSize(bytes) {
+  if (bytes >= 1048576) return roundPrec(bytes / 1048576, 2) + ' MB';
+  if (bytes >= 1024) return roundPrec(bytes / 1024, 2) + ' kB';
+  return roundPrec(bytes, 2) + ' B';
+}
+
+function generateRandomData(size) {
+  var buffer = new Buffer(size);
+  for (var i = 0; i < size; ++i) {
+    buffer[i] = ~~(Math.random() * 127);
+  }
+  return buffer;
+}
+
+if (cluster.isMaster) {
+  var wss = new WebSocketServer({port: 8181}, function() {
+    cluster.fork();
+  });
+  wss.on('connection', function(ws) {
+    ws.on('message', function(data, flags) {
+      ws.send(data, {binary: flags&&flags.binary});
+    });
+    ws.on('close', function() {});
+  });
+  cluster.on('death', function(worker) {
+    wss.close();
+  });
+}
+else {
+  var cursor = ansi(process.stdout);
+
+  var configs = [
+    [true, 10000, 64],
+    [true, 5000, 16*1024],
+    [true, 1000, 128*1024],
+    [true, 100, 1024*1024],
+    [true, 1, 500*1024*1024],
+    [false, 10000, 64],
+    [false, 5000, 16*1024],
+    [false, 1000, 128*1024],
+    [false, 100, 1024*1024],
+  ];
+
+  var largest = configs[0][1];
+  for (var i = 0, l = configs.length; i < l; ++i) {
+    if (configs[i][2] > largest) largest = configs[i][2];
+  }
+
+  console.log('Generating %s of test data ...', humanSize(largest));
+  var randomBytes = generateRandomData(largest);
+
+  function roundtrip(useBinary, roundtrips, size, cb) {
+    var data = randomBytes.slice(0, size);
+    var prefix = util.format('Running %d roundtrips of %s %s data', roundtrips, humanSize(size), useBinary ? 'binary' : 'text');
+    console.log(prefix);
+    var client = new WebSocket('ws://localhost:' + '8181');
+    var dt;
+    var roundtrip = 0;
+    function send() {
+      client.send(data, {binary: useBinary});
+    }
+    client.on('error', function(e) {
+      console.error(e);
+      process.exit();
+    });
+    client.on('open', function() {
+      dt = Date.now();
+      send();
+    });
+    client.on('message', function(data, flags) {
+      if (++roundtrip == roundtrips) {
+        var elapsed = Date.now() - dt;
+        cursor.up();
+        console.log('%s:\t%ss\t%s'
+          , useBinary ? prefix.green : prefix.cyan
+          , roundPrec(elapsed / 1000, 1).toString().green.bold
+          , (humanSize((size * roundtrips) / elapsed * 1000) + '/s').blue.bold);
+        client.close();
+        cb();
+        return;
+      }
+      process.nextTick(send);
+    });
+  }
+
+  (function run() {
+    if (configs.length == 0) process.exit();
+    var config = configs.shift();
+    config.push(run);
+    roundtrip.apply(null, config);
+  })();
+}

data/spec/iface/driver/assets/node_modules/socket.io/node_modules/socket.io-client/node_modules/engine.io-client/node_modules/ws/bench/util.js

@@ -0,0 +1,105 @@
+/*!
+ * ws: a node.js websocket client
+ * Copyright(c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+ * MIT Licensed
+ */
+
+/**
+ * Returns a Buffer from a "ff 00 ff"-type hex string.
+ */
+
+getBufferFromHexString = function(byteStr) {
+  var bytes = byteStr.split(' ');
+  var buf = new Buffer(bytes.length);
+  for (var i = 0; i < bytes.length; ++i) {
+    buf[i] = parseInt(bytes[i], 16);
+  }
+  return buf;
+}
+
+/**
+ * Returns a hex string from a Buffer.
+ */
+
+getHexStringFromBuffer = function(data) {
+  var s = '';
+  for (var i = 0; i < data.length; ++i) {
+    s += padl(data[i].toString(16), 2, '0') + ' ';
+  }
+  return s.trim();
+}
+
+/**
+ * Splits a buffer in two parts.
+ */
+
+splitBuffer = function(buffer) {
+  var b1 = new Buffer(Math.ceil(buffer.length / 2));
+  buffer.copy(b1, 0, 0, b1.length);
+  var b2 = new Buffer(Math.floor(buffer.length / 2));
+  buffer.copy(b2, 0, b1.length, b1.length + b2.length);
+  return [b1, b2];
+}
+
+/**
+ * Performs hybi07+ type masking on a hex string or buffer.
+ */
+
+mask = function(buf, maskString) {
+  if (typeof buf == 'string') buf = new Buffer(buf);
+  var mask = getBufferFromHexString(maskString || '34 83 a8 68');
+  for (var i = 0; i < buf.length; ++i) {
+    buf[i] ^= mask[i % 4];    
+  }
+  return buf;
+}
+
+/**
+ * Returns a hex string representing the length of a message
+ */
+ 
+getHybiLengthAsHexString = function(len, masked) {  
+  if (len < 126) {
+    var buf = new Buffer(1);
+    buf[0] = (masked ? 0x80 : 0) | len;
+  }
+  else if (len < 65536) {
+    var buf = new Buffer(3);
+    buf[0] = (masked ? 0x80 : 0) | 126;
+    getBufferFromHexString(pack(4, len)).copy(buf, 1);
+  }
+  else {
+    var buf = new Buffer(9);
+    buf[0] = (masked ? 0x80 : 0) | 127;
+    getBufferFromHexString(pack(16, len)).copy(buf, 1);
+  }
+  return getHexStringFromBuffer(buf);
+}
+
+/**
+ * Unpacks a Buffer into a number.
+ */
+
+unpack = function(buffer) {
+  var n = 0;
+  for (var i = 0; i < buffer.length; ++i) {
+    n = (i == 0) ? buffer[i] : (n * 256) + buffer[i];
+  }
+  return n;
+}
+
+/**
+ * Returns a hex string, representing a specific byte count 'length', from a number.
+ */
+
+pack = function(length, number) {
+  return padl(number.toString(16), length, '0').replace(/([0-9a-f][0-9a-f])/gi, '$1 ').trim();
+}
+
+/**
+ * Left pads the string 's' to a total length of 'n' with char 'c'.
+ */
+
+padl = function(s, n, c) { 
+  return new Array(1 + n - s.length).join(c) + s;
+}

data/spec/iface/driver/assets/node_modules/socket.io/node_modules/socket.io-client/node_modules/engine.io-client/node_modules/ws/bin/wscat

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+
+/*!
+ * ws: a node.js websocket client
+ * Copyright(c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var WebSocket = require('../')
+  , fs = require('fs')
+  , program = require('commander')
+  , util = require('util')
+  , events = require('events')
+  , readline = require('readline');
+
+/**
+ * InputReader - processes console input
+ */
+
+function Console() {
+  this.stdin = process.stdin;
+  this.stdout = process.stdout;
+
+  this.readlineInterface = readline.createInterface(this.stdin, this.stdout);
+
+  var self = this;
+  this.readlineInterface.on('line', function(data) {
+    self.emit('line', data);
+  });
+  this.readlineInterface.on('close', function() {
+    self.emit('close');
+  });
+
+  this._resetInput = function() {
+    self.clear();
+  }
+}
+util.inherits(Console, events.EventEmitter);
+
+Console.Colors = {
+  Red: '\033[31m',
+  Green: '\033[32m',
+  Yellow: '\033[33m',
+  Blue: '\033[34m',
+  Default: '\033[39m'
+};
+
+Console.prototype.prompt = function() {
+  this.readlineInterface.prompt();
+}
+
+Console.prototype.print = function(msg, color) {
+  this.clear();
+  color = color || Console.Colors.Default;
+  this.stdout.write(color + msg + Console.Colors.Default + '\n');
+  this.prompt();
+}
+
+Console.prototype.clear = function() {
+  this.stdout.write('\033[2K\033[E');
+}
+
+Console.prototype.pause = function() {
+  this.stdin.on('keypress', this._resetInput);
+}
+
+Console.prototype.resume = function() {
+  this.stdin.removeListener('keypress', this._resetInput);
+}
+
+/**
+ * The actual application
+ */
+
+var version = JSON.parse(fs.readFileSync(__dirname + '/../package.json', 'utf8')).version;
+program
+  .version(version)
+  .usage('[options] <url>')
+  .option('-l, --listen <port>', 'listen on port')
+  .option('-c, --connect <url>', 'connect to a websocket server')
+  .option('-p, --protocol <version>', 'optional protocol version')
+  .option('-o, --origin <origin>', 'optional origin')
+  .option('--host <host>', 'optional host')
+  .option('-s, --subprotocol <protocol>', 'optional subprotocol')
+  .parse(process.argv);
+
+if (program.listen && program.connect) {
+  console.error('\033[33merror: use either --listen or --connect\033[39m');
+  process.exit(-1);
+}
+else if (program.listen) {
+  var wsConsole = new Console();
+  wsConsole.pause();
+  var options = {};
+  if (program.protocol) options.protocolVersion = program.protocol;
+  if (program.origin) options.origin = program.origin;
+  if (program.subprotocol) options.protocol = program.subprotocol;
+  var ws = null;
+  var wss = new WebSocket.Server({port: program.listen}, function() {
+    wsConsole.print('listening on port ' + program.listen + ' (press CTRL+C to quit)', Console.Colors.Green);
+    wsConsole.clear();
+  });
+  wsConsole.on('close', function() {
+    if (ws) {
+      try {
+        ws.close();
+      }
+      catch (e) {}
+    }
+    process.exit(0);
+  });
+  wsConsole.on('line', function(data) {
+    if (ws) {
+      ws.send(data, {mask: false});
+      wsConsole.prompt();
+    }
+  });
+  wss.on('connection', function(newClient) {
+    if (ws) {
+      // limit to one client
+      newClient.terminate();
+      return;
+    };
+    ws = newClient;
+    wsConsole.resume();
+    wsConsole.prompt();
+    wsConsole.print('client connected', Console.Colors.Green);
+    ws.on('close', function() {
+      wsConsole.print('disconnected', Console.Colors.Green);
+      wsConsole.clear();
+      wsConsole.pause();
+      ws = null;
+    });
+    ws.on('error', function(code, description) {
+      wsConsole.print('error: ' + code + (description ? ' ' + description : ''), Console.Colors.Yellow);
+    });
+    ws.on('message', function(data, flags) {
+      wsConsole.print('< ' + data, Console.Colors.Blue);
+    });
+  });
+  wss.on('error', function(error) {
+    wsConsole.print('error: ' + error.toString(), Console.Colors.Yellow);
+    process.exit(-1);
+  });
+}
+else if (program.connect) {
+  var wsConsole = new Console();
+  var options = {};
+  if (program.protocol) options.protocolVersion = program.protocol;
+  if (program.origin) options.origin = program.origin;
+  if (program.subprotocol) options.protocol = program.subprotocol;
+  if (program.host) options.host = program.host;
+  var ws = new WebSocket(program.connect, options);
+  ws.on('open', function() {
+    wsConsole.print('connected (press CTRL+C to quit)', Console.Colors.Green);
+    wsConsole.on('line', function(data) {
+      ws.send(data, {mask: true});
+      wsConsole.prompt();
+    });
+  });
+  ws.on('close', function() {
+    wsConsole.print('disconnected', Console.Colors.Green);
+    wsConsole.clear();
+    process.exit();
+  });
+  ws.on('error', function(code, description) {
+    wsConsole.print('error: ' + code + (description ? ' ' + description : ''), Console.Colors.Yellow);
+    process.exit(-1);
+  });
+  ws.on('message', function(data, flags) {
+    wsConsole.print('< ' + data, Console.Colors.Blue);
+  });
+  wsConsole.on('close', function() {
+    if (ws) {
+      try {
+        ws.close();
+      }
+      catch(e) {}
+      process.exit();
+    }
+  });
+}
+else {
+  console.error('\033[33merror: use either --listen or --connect\033[39m');
+  process.exit(-1);
+}