Commit 97371a8

@@ -0,0 +1,94 @@
+"use strict";
+
+var http = require('http');
+var underscore = require('underscore');
+
+var checkServers = exports.checkServers = function (array, success, error) {
+  var upCount = 0,
+      errored = false,
+      target,
+      i;
+  for (i = 0; i < array.length; i++) {
+    check(
+      array[i],
+      function () {
+        upCount += 1;
+        if (upCount === array.length) {
+          success();
+        }
+      },
+      function () {
+        if (errored === false) {
+          errored = true;
+          error();
+        }
+      }
+    );
+  }
+}
+
+var check = exports.check = function (connectionOptions, success, error) {
+  var baseOptions = {
+    path: "/",
+    method: 'HEAD'
+  };
+  var options = underscore.extend(baseOptions, connectionOptions);
+  var request = http.request(options, function (response) {
+    response.on('data', function () {
+      return;
+    });
+    response.on('end', function () {
+      if (response.statusCode === 200) {
+        console.log("Upstream server is up.");
+        success();
+      } else if (response.statusCode === 400) {
+        console.log("400 response code. We may be using the wrong secret.");
+        error();
+      } else if (response.statusCode === 500) {
+        console.log("500 response code. Shield may be failing to come up.");
+        error();
+      } else {
+        console.log("Unexpected response code %s.", response.statusCode);
+        error();
+      }
+    });
+  });
+
+  request.setTimeout(1000, function (socket) {
+      console.log("Timeout checking backend. The backend is probably down.");
+      request.abort();
+  });
+
+  request.on("error", function (err) {
+    console.log("Error checking backend. The immediate upstream is probably down.");
+    error();
+  });
+
+  request.end();
+};
+
+var checkWithBackoff = exports.checkWithBackoff = function (connectionOptions, success, failure, attempts, backoff) {
+  var attempts,
+      backoff = backoff || 500; // ms
+  if (attempts === undefined) {
+    attempts = 4;
+  }
+  console.log("Checking if backends are up.");
+  var failedTry = function () {
+    if (attempts >= 1) {
+      // Try again, doubling the backoff time
+      setTimeout(
+        checkWithBackoff,
+        backoff,
+        connectionOptions,
+        success,
+        failure,
+        attempts - 1,
+        backoff * 2
+      );
+    } else {
+      failure();
+    }
+  };
+  check(connectionOptions, success, failedTry);
+};
\ No newline at end of file

@@ -0,0 +1,408 @@
+// This file is a port of [node-http-proxy](https://github.com/nodejitsu/node-http-proxy)
+// The purpose of the port is to enable connections to the backend
+// server over a Unix socket file.
+
+// node-http-proxy includes the following message:
+
+// Copyright (c) 2010 Charlie Robbins, Mikeal Rogers, Fedor Indutny, & Marak Squires
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+"use strict";
+
+var http = require('http');
+var url = require('url')
+var events = require('events');
+var util = require('util');
+
+var HttpProxy = exports.HttpProxy = function(options) {
+  events.EventEmitter.call(this);
+  var self  = this;
+  this.target = options.target;
+  this.enable  = {};
+  this.timeout = options.timeout;
+}
+
+util.inherits(HttpProxy, events.EventEmitter);
+
+exports.createServer = function (options, callback) {
+  var handlers = [callback];
+  var proxy = new HttpProxy(options);
+  function handler(req, res) {
+    return callback(req, res, proxy);
+  }
+  var server = http.createServer(handler);
+  server.on('close', function () {
+    proxy.close();
+  });
+  server.proxy = proxy;
+  return server;
+}
+
+//
+// ### function proxyRequest (req, res, buffer)
+// #### @req {ServerRequest} Incoming HTTP Request to proxy.
+// #### @res {ServerResponse} Outgoing HTTP Request to write proxied data to.
+// #### @buffer {Object} Result from `httpProxy.buffer(req)`
+//
+HttpProxy.prototype.proxyRequest = function (req, res, buffer) {
+  var self = this,
+      errState = false,
+      outgoing = {},
+      reverseProxy,
+      location;
+
+  // If this is a DELETE request then set the "content-length"
+  // header (if it is not already set)
+  if (req.method === 'DELETE') {
+    req.headers['content-length'] = req.headers['content-length'] || '0';
+  }
+
+  //
+  // Add common proxy headers to the request so that they can
+  // be availible to the proxy target server. If the proxy is
+  // part of proxy chain it will append the address:
+  //
+  // * `x-forwarded-for`: IP Address of the original request
+  // * `x-forwarded-proto`: Protocol of the original request
+  // * `x-forwarded-port`: Port of the original request.
+  //
+  if (this.enable.xforward && req.connection && req.socket) {
+    if (req.headers['x-forwarded-for']) {
+      var addressToAppend = "," + req.connection.remoteAddress || req.socket.remoteAddress;
+      req.headers['x-forwarded-for'] += addressToAppend;
+    }
+    else {
+      req.headers['x-forwarded-for'] = req.connection.remoteAddress || req.socket.remoteAddress;
+    }
+
+    if (req.headers['x-forwarded-port']) {
+      var portToAppend = "," + getPortFromHostHeader(req);
+      req.headers['x-forwarded-port'] += portToAppend;
+    }
+    else {
+      req.headers['x-forwarded-port'] = getPortFromHostHeader(req);
+    }
+
+    if (req.headers['x-forwarded-proto']) {
+      var protoToAppend = "," + getProto(req);
+      req.headers['x-forwarded-proto'] += protoToAppend;
+    }
+    else {
+      req.headers['x-forwarded-proto'] = getProto(req);
+    }
+  }
+
+  if (this.timeout) {
+    req.socket.setTimeout(this.timeout);
+  }
+
+  //
+  // Emit the `start` event indicating that we have begun the proxy operation.
+  //
+  this.emit('start', req, res, this.target);
+
+  //
+  // #### function proxyError (err)
+  // #### @err {Error} Error contacting the proxy target
+  // Short-circuits `res` in the event of any error when
+  // contacting the proxy target at `host` / `port`.
+  //
+  function proxyError(err) {
+    errState = true;
+
+    //
+    // Emit an `error` event, allowing the application to use custom
+    // error handling. The error handler should end the response.
+    //
+    if (self.emit('proxyError', err, req, res)) {
+      return;
+    }
+
+    res.writeHead(500, { 'Content-Type': 'application/json' });
+
+    if (req.method !== 'HEAD') {
+      var contents = {
+        'error': err
+      }
+      res.write(JSON.stringify(contents));
+    }
+
+    try { res.end() }
+    catch (ex) { console.error("res.end error: %s", ex.message) }
+  }
+
+  //
+  // Setup outgoing proxy with relevant properties.
+  //
+  outgoing.host       = this.target.host;
+  outgoing.hostname   = this.target.hostname;
+  outgoing.port       = this.target.port;
+  outgoing.socketPath = this.target.socketPath;
+  outgoing.agent      = this.target.agent;
+  outgoing.method     = req.method;
+  outgoing.path       = url.parse(req.url).path;
+  outgoing.headers    = req.headers;
+
+  //
+  // If the changeOrigin option is specified, change the
+  // origin of the host header to the target URL! Please
+  // don't revert this without documenting it!
+  //
+  if (this.changeOrigin) {
+    outgoing.headers.host = this.target.host;
+    // Only add port information to the header if not default port
+    // for this protocol.
+    // See https://github.com/nodejitsu/node-http-proxy/issues/458
+    if (this.target.port !== 443 && this.target.https ||
+      this.target.port !== 80 && !this.target.https) {
+      outgoing.headers.host += ':' + this.target.port;
+    }
+  }
+
+  //
+  // Open new HTTP request to internal resource with will act
+  // as a reverse proxy pass
+  //
+  reverseProxy = http.request(outgoing, function (response) {
+    //
+    // Process the `reverseProxy` `response` when it's received.
+    //
+    if (req.httpVersion === '1.0') {
+      if (req.headers.connection) {
+        response.headers.connection = req.headers.connection
+      } else {
+        response.headers.connection = 'close'
+      }
+    } else if (!response.headers.connection) {
+      if (req.headers.connection) { response.headers.connection = req.headers.connection }
+      else {
+        response.headers.connection = 'keep-alive'
+      }
+    }
+
+    // Remove `Transfer-Encoding` header if client's protocol is HTTP/1.0
+    // or if this is a DELETE request with no content-length header.
+    // See: https://github.com/nodejitsu/node-http-proxy/pull/373
+    if (req.httpVersion === '1.0' || (req.method === 'DELETE'
+      && !req.headers['content-length'])) {
+      delete response.headers['transfer-encoding'];
+    }
+
+    if ((response.statusCode === 301 || response.statusCode === 302)
+      && typeof response.headers.location !== 'undefined') {
+      location = url.parse(response.headers.location);
+      if (location.host === req.headers.host) {
+        if (self.source.https && !self.target.https) {
+          response.headers.location = response.headers.location.replace(/^http\:/, 'https:');
+        }
+        if (self.target.https && !self.source.https) {
+          response.headers.location = response.headers.location.replace(/^https\:/, 'http:');
+        }
+      }
+    }
+
+    //
+    // When the `reverseProxy` `response` ends, end the
+    // corresponding outgoing `res` unless we have entered
+    // an error state. In which case, assume `res.end()` has
+    // already been called and the 'error' event listener
+    // removed.
+    //
+    var ended = false;
+    response.on('close', function () {
+      if (!ended) { response.emit('end') }
+    });
+
+    //
+    // After reading a chunked response, the underlying socket
+    // will hit EOF and emit a 'end' event, which will abort
+    // the request. If the socket was paused at that time,
+    // pending data gets discarded, truncating the response.
+    // This code makes sure that we flush pending data.
+    //
+    response.connection.on('end', function () {
+      if (response.readable && response.resume) {
+        response.resume();
+      }
+    });
+
+    response.on('end', function () {
+      ended = true;
+      if (!errState) {
+        try { res.end() }
+        catch (ex) { console.error("res.end error: %s", ex.message) }
+
+        // Emit the `end` event now that we have completed proxying
+        self.emit('end', req, res, response);
+      }
+    });
+
+    // Allow observer to modify headers or abort response
+    try { self.emit('proxyResponse', req, res, response) }
+    catch (ex) {
+      errState = true;
+      return;
+    }
+
+    // Set the headers of the client response
+    if (res.sentHeaders !== true) {
+      Object.keys(response.headers).forEach(function (key) {
+        res.setHeader(key, response.headers[key]);
+      });
+      res.writeHead(response.statusCode);
+    }
+
+    function ondata(chunk) {
+      if (res.writable) {
+        // Only pause if the underlying buffers are full,
+        // *and* the connection is not in 'closing' state.
+        // Otherwise, the pause will cause pending data to
+        // be discarded and silently lost.
+        if (false === res.write(chunk) && response.pause
+            && response.connection.readable) {
+          response.pause();
+        }
+      }
+    }
+
+    response.on('data', ondata);
+
+    function ondrain() {
+      if (response.readable && response.resume) {
+        response.resume();
+      }
+    }
+
+    res.on('drain', ondrain);
+  });
+
+  // allow unlimited listeners
+  reverseProxy.setMaxListeners(0);
+
+  //
+  // Handle 'error' events from the `reverseProxy`. Setup timeout override if needed
+  //
+  reverseProxy.once('error', proxyError);
+
+  // Set a timeout on the socket if `this.timeout` is specified.
+  reverseProxy.once('socket', function (socket) {
+    if (self.timeout) {
+      socket.setTimeout(self.timeout);
+    }
+  });
+
+  //
+  // Handle 'error' events from the `req` (e.g. `Parse Error`).
+  //
+  req.on('error', proxyError);
+
+  //
+  // If `req` is aborted, we abort our `reverseProxy` request as well.
+  //
+  req.on('aborted', function () {
+    reverseProxy.abort();
+  });
+
+  //
+  // For each data `chunk` received from the incoming
+  // `req` write it to the `reverseProxy` request.
+  //
+  req.on('data', function (chunk) {
+    if (!errState) {
+      var flushed = reverseProxy.write(chunk);
+      if (!flushed) {
+        req.pause();
+        reverseProxy.once('drain', function () {
+          try { req.resume() }
+          catch (er) { console.error("req.resume error: %s", er.message) }
+        });
+
+        //
+        // Force the `drain` event in 100ms if it hasn't
+        // happened on its own.
+        //
+        setTimeout(function () {
+          reverseProxy.emit('drain');
+        }, 100);
+      }
+    }
+  });
+
+  //
+  // When the incoming `req` ends, end the corresponding `reverseProxy`
+  // request unless we have entered an error state.
+  //
+  req.on('end', function () {
+    if (!errState) {
+      reverseProxy.end();
+    }
+  });
+
+  // Aborts reverseProxy if client aborts the connection.
+  req.on('close', function () {
+    if (!errState) {
+      reverseProxy.abort();
+    }
+  });
+
+  //
+  // If we have been passed buffered data, resume it.
+  //
+  if (buffer) {
+    return !errState
+      ? buffer.resume()
+      : buffer.destroy();
+  }
+};
+
+exports.buffer = function (obj) {
+  var events = [],
+      onData,
+      onEnd;
+
+  obj.on('data', onData = function (data, encoding) {
+    events.push(['data', data, encoding]);
+  });
+
+  obj.on('end', onEnd = function (data, encoding) {
+    events.push(['end', data, encoding]);
+  });
+
+  return {
+    end: function () {
+      obj.removeListener('data', onData);
+      obj.removeListener('end', onEnd);
+    },
+    destroy: function () {
+      this.end();
+        this.resume = function () {
+          console.error("Cannot resume buffer after destroying it.");
+        };
+
+        onData = onEnd = events = obj = null;
+    },
+    resume: function () {
+      this.end();
+      for (var i = 0, len = events.length; i < len; ++i) {
+        obj.emit.apply(obj, events[i]);
+      }
+    }
+  };
+};
\ No newline at end of file

@@ -0,0 +1,41 @@
+"use strict";
+
+var crypto = require('crypto');
+
+var sum = exports.sum = function (array) {
+  return array.reduce(function (a, b) { return a + b; });
+}
+
+exports.average = function (array) {
+  return sum(array) / array.length;
+}
+
+exports.sign = function (nonce, secret) {
+  var hmacCreator = crypto.createHmac('sha256', secret);
+  hmacCreator.update(nonce);
+  return hmacCreator.digest('hex');
+}
+
+exports.hash = function (value) {
+  var hashCreator = crypto.createHash('sha256');
+  hashCreator.update(value);
+  return hashCreator.digest('hex');
+}
+
+exports.generateRandom = function (byteCount) {
+  var buf = crypto.randomBytes(byteCount);
+  return buf.toString('hex');
+}
+
+exports.randString = function (randGenerator, length) {
+  var chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZ';
+  length = length || 32;
+  var string = '';
+  var charIndex;
+  var randomNumber;
+  for (charIndex = 0; charIndex < length; charIndex++) {
+    randomNumber = Math.floor(randGenerator() * chars.length);
+    string += chars.substring(randomNumber, randomNumber + 1);
+  }
+  return string;
+}
\ No newline at end of file

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+
+"use strict";
+
+var crypto = require('crypto');
+var fs = require('fs');
+var http = require("http");
+var nopt = require('nopt');
+var url = require("url");
+
+var util = require('./lib/util');
+
+function respond(response, statusCode, contents) {
+  response.writeHead(statusCode, {"Content-Type": "application/json"});
+  if (contents) {
+    response.write(JSON.stringify(contents));
+  }
+  response.end();
+}
+
+function respondError(response, responseCode, errorMessage) {
+  var contents = {
+    "error": errorMessage
+  };
+  respond(response, responseCode, contents);
+}
+
+var DownTime = function () {
+  this.startTime = Date.now();
+};
+DownTime.prototype.end = function () {
+  this.endTime = Date.now();
+};
+DownTime.prototype.duration = function () {
+  var endTime = this.endTime || Date.now()
+  return (endTime - this.startTime);
+};
+
+var QueueServer = function (responseDelay, allowedInFlight, maxQueueLength) {
+  this.responseDelay = responseDelay;
+  this.allowedInFlight = allowedInFlight;
+  this.maxQueueLength = maxQueueLength;
+  this.inFlight = 0;
+  this.queued = [];
+  this.downtimes = [];
+};
+QueueServer.prototype.pushRequest = function (reqData) {
+  if (this.queued.length >= this.maxQueueLength) {
+    respondError(reqData.response, "500", "Server is falling over from the load.");
+  } else {
+    this.queued.push(reqData);
+  }
+};
+QueueServer.prototype.popRequest = function () {
+  if (this.queued.length === 0) {
+    this.inFlight -= 1;
+    this.downtimes.push(new DownTime());
+    return;
+  }
+  var value = this.queued[0];
+  this.queued.splice(0, 1);
+  this.handleRequest(value);
+};
+QueueServer.prototype.handleRequest = function (reqData) {
+  if (reqData.closed) {
+    process.nextTick(this.popRequest.bind(this));
+    return;
+  }
+  var parsed = url.parse(reqData.request.url, true),
+      nonce = parsed.query.nonce,
+      contents,
+      hmac;
+  if (nonce === undefined) {
+    respondError(reqData.response, "400", "No nonce was provided.");
+    process.nextTick(this.popRequest.bind(this));
+    return;
+  }
+  hmac = util.sign(nonce, this.secret);
+  contents = {
+    "hmac": hmac
+  };
+  setTimeout(this.waitAndRespond.bind(this), this.responseDelay, reqData, contents);
+};
+QueueServer.prototype.waitAndRespond = function (reqData, contents) {
+  if (reqData.closed) {
+    console.log("Client timed out while waiting for us.");
+  } else {
+    respond(reqData.response, 200, contents);
+  }
+  this.popRequest();
+};
+
+var RequestData = function (request, response) {
+  this.request = request;
+  this.response = response;
+  this.closed = false;
+};
+
+function handleGET(queue, request, response) {
+  var reqData = new RequestData(request, response);
+  response.on('close', function () {
+    reqData.closed = true;
+  });
+  if (queue.inFlight >= queue.allowedInFlight) {
+    // Save this request for later
+    queue.pushRequest(reqData);
+  } else {
+    // Handle now
+    if (queue.downtimes.length != 0) {
+      queue.downtimes[queue.downtimes.length - 1].end();
+    }
+    queue.inFlight += 1;
+    queue.handleRequest(reqData);
+  }
+}
+
+function handleHEAD(validPath, request, response) {
+  var parsed = url.parse(request.url);
+  if (parsed['pathname'] == "/" + validPath) {
+    respond(response, 200);
+  } else {
+    respond(response, 400);
+  }
+}
+
+function main() {
+  var opts = {
+    "secret": String,
+    "in-socket": String,
+    "in-port": String,
+  };
+  var parsed = nopt(opts),
+      secret = parsed.secret || "defaultsecret",
+      secretHash = util.hash(secret),
+      listenTarget;
+
+  if (parsed['in-socket'] !== undefined && parsed['in-port'] !== undefined) {
+    console.log("Cannot specify both an in-port and an in-socket. Exiting.");
+    process.exit(1);
+  } else if (parsed['in-socket']) {
+    listenTarget = parsed['in-socket'];
+  } else {
+    // Default: listen on port 3001
+    listenTarget = parsed['in-port'] || '3001';
+  }
+  // Response delay in ms, Allowed in flight connections, Allowed queue length
+  var queue = new QueueServer(75, 2, 4);
+  queue.secret = secret;
+  var server = http.createServer(function (request, response) {
+    switch (request.method) {
+    case "GET":
+      handleGET(queue, request, response);
+      break;
+    case "HEAD":
+      handleHEAD(secretHash, request, response);
+      break;
+    default:
+      respondUserError(response, "Unsupported HTTP method " + request.method);
+    }
+  });
+
+  server.on("listening", function () {
+    if (parsed['in-socket'] !== undefined) {
+      fs.chmodSync(parsed['in-socket'], "0666");
+    }
+  })
+
+  console.log("The backend is up and listening.");
+  server.listen(listenTarget);
+}
+
+main();

@@ -0,0 +1,359 @@
+#!/usr/bin/env node
+
+"use strict";
+
+var assert = require('assert');
+var events = require('events');
+var fs = require('fs');
+var http = require('http');
+var nopt = require('nopt');
+var path = require('path');
+var seedModule = require('seed-random');
+var underscore = require('underscore');
+
+var checkServer = require('./lib/check_server');
+var util = require('./lib/util');
+
+var Request = function (client, roundIndex, nonce) {
+  this.client = client;
+  this.simulation = client.simulation;
+  this.roundIndex = roundIndex;
+  this.nonce = nonce;
+};
+
+Request.prototype.log = function (message, force) {
+  if (this.client.simulation.debugOutput || force) {
+    console.log('Request[%s,%s]: %s',
+      this.client.ip.slice(0, 8),
+      this.nonce.slice(0, 8),
+      message);
+  }
+};
+
+Request.prototype.handleResponse = function (res, pageData) {
+  var jsonResponse,
+      hmac;
+  if (res.statusCode !== 200) {
+    this.log("Non-200 return code.");
+    return;
+  }
+  try {
+    jsonResponse = JSON.parse(pageData);
+  } catch (err) {
+    this.log("Could not parse response body.", true);
+    return;
+  }
+  if (!jsonResponse.hmac) {
+    this.log("Responded with no HMAC.", true);
+    return;
+  }
+  hmac = util.sign(this.nonce, this.client.simulation.secret);
+  if (hmac === jsonResponse.hmac) {
+    this.simulation.registerSuccess(this.client, this.roundIndex, this.latency);
+  } else {
+    this.log("Responded with invalid HMAC", true);
+  }
+};
+
+Request.prototype.run = function () {
+  var self = this;
+  var baseOptions = {
+    path: '/?nonce=' + self.nonce,
+    headers: {
+      'X-Forwarded-For': self.client.ip
+    }
+  };
+  var options = underscore.extend(self.client.simulation.connection, baseOptions);
+  var startTime = Date.now();
+  var req = http.get(options, function (res) {
+    var pageData = "";
+    res.on('data', function (chunk) {
+      pageData += chunk;
+    });
+
+    res.on('end', function () {
+      self.latency = Date.now() - startTime;
+      self.handleResponse(res, pageData);
+    });
+  });
+
+  req.on('socket', function (socket) {
+    socket.setMaxListeners(0)
+    socket.setTimeout(1000); // In ms
+    socket.on('timeout', function () {
+      self.log("Timeout. Aborting.");
+      req.abort();
+    });
+  });
+
+  req.on("error", function (e) {
+    // Socket errors are expected when we our resources are small compared
+    // to the traffic that we try to push through.
+    self.log("Sword HTTP error: " + e.message);
+  });
+};
+
+var Client = function (simulation, birthRound) {
+  this.simulation = simulation;
+  this.ip = simulation.randString(48);
+  simulation.clients[this.ip] = this;
+  this.birthRound = birthRound;
+  this.lifetime = simulation.simulationParameters.clientLifetime;
+  if (simulation.random() > simulation.simulationParameters.pElephant) {
+    this.type = "mouse";
+    this.delayUntilStart = simulation.random() * simulation.simulationParameters.roundLength;
+    this.requestsPerRound = simulation.simulationParameters.mouseRequestsPerRound;
+  } else {
+    this.type = "elephant";
+    this.delayUntilStart = (simulation.random() / 5) * simulation.simulationParameters.roundLength;
+    this.requestsPerRound = simulation.simulationParameters.elephantRequestsPerRound;
+  }
+};
+
+Client.prototype.expired = function (roundIndex) {
+  return (this.lifetime <= roundIndex - this.birthRound);
+};
+
+Client.prototype.waitTime = function () {
+  return this.simulation.simulationParameters.roundLength / this.requestsPerRound;
+};
+
+Client.prototype.runMouse = function (roundIndex) {
+  var roundLength = this.simulation.simulationParameters.roundLength,
+      waitBetweenRequests = (roundLength - this.delayUntilStart) / this.requestsPerRound;
+  setTimeout(
+    this.sendRequest.bind(this),
+    this.delayUntilStart,
+    0,
+    roundIndex,
+    waitBetweenRequests
+  );
+};
+
+Client.prototype.runElephant = function (roundIndex) {
+  var waitBetweenRequests = this.simulation.simulationParameters.roundLength / this.requestsPerRound;
+  this.sendRequest(0, roundIndex, waitBetweenRequests);
+};
+
+Client.prototype.run = function (roundIndex) {
+  switch (this.type) {
+  case "mouse":
+    this.runMouse(roundIndex);
+    break;
+  case "elephant":
+    this.runElephant(roundIndex);
+    break;
+  default:
+    assert(false, "Fell through cases.");
+  }
+};
+
+Client.prototype.sendRequest = function (requestIndex, roundIndex, waitBetweenRequests) {
+  var requestNonce = util.generateRandom(64);
+  var request = new Request(this, roundIndex, requestNonce);
+  request.run();
+  var nextRequestIndex = requestIndex + 1;
+  if (nextRequestIndex < this.requestsPerRound) {
+    setTimeout(
+      this.sendRequest.bind(this),
+      waitBetweenRequests,
+      nextRequestIndex,
+      roundIndex,
+      waitBetweenRequests
+    );
+  }
+};
+
+var Simulation = function (seed, simulationParameters) {
+  this.simulationParameters = simulationParameters;
+  this.random = seedModule(seed);
+  this.simulationResults = [];
+  this.responseTotal = 0;
+  this.clients = {};
+  this.currentRound = -1;
+  this.roundStartTimes = [];
+};
+
+Simulation.prototype.randString = function (length) {
+  return util.randString(this.random, length);
+};
+
+Simulation.prototype.duration = function () {
+  return this.simulationParameters['roundLength'] * this.simulationParameters['roundCount'];
+};
+
+Simulation.prototype.runSimulation = function (clients) {
+  if (clients === undefined) {
+    clients = [];
+  }
+  var roundIndex = ++this.currentRound;
+  var i;
+  var client;
+
+  this.roundStartTimes[roundIndex] = Date.now();
+  this.simulationResults[roundIndex] = [];
+
+  var runningClients = [];
+  // Create clients to replace any that have expired
+  for (i = 0; i < clients.length; i++) {
+    client = clients[i];
+    if (!client.expired(roundIndex)) {
+      runningClients.push(client);
+    }
+  }
+  var clientsToCreate = this.simulationParameters.clientsPerRound - runningClients.length;
+  for (i = 0; i < clientsToCreate; i++) {
+    client = new Client(this, roundIndex);
+    runningClients.push(client);
+  }
+  // Run the clients
+  for (i = 0; i < runningClients.length; i++) {
+    runningClients[i].run(roundIndex);
+  }
+  if (roundIndex + 1 >= this.simulationParameters.roundCount) {
+    setTimeout(
+      this.scoreSimulation.bind(this),
+      this.simulationParameters.roundLength
+    );
+  } else {
+    setTimeout(
+      this.runSimulation.bind(this),
+      this.simulationParameters.roundLength,
+      runningClients
+    );
+  }
+};
+
+Simulation.prototype.registerSuccess = function (client, roundIndex, latency) {
+  this.responseTotal += 1;
+  if (client.type === "elephant") {
+    // No points for elephants!
+    return;
+  }
+  var mouseCount = this.simulationResults[roundIndex][client.ip] || 0;
+  this.simulationResults[roundIndex][client.ip] = mouseCount + 1;
+  this.maxLatency = this.maxLatency ? Math.max(this.maxLatency, latency) : latency;
+};
+
+Simulation.prototype.scoreRound = function (roundResults) {
+  console.log("Round");
+  var score = 0;
+  var self = this;
+  Object.keys(roundResults).forEach(function (ip) {
+    var successes = roundResults[ip];
+    var client = self.clients[ip];
+    console.log("IP %s (%s): %d", ip.slice(0, 8), client.type, successes);
+    score += successes;
+  });
+  if (score == 0) {
+    console.log("No mice got through this round.");
+  }
+  return score;
+};
+
+Simulation.prototype.calculateDowntime = function (responseCount) {
+  // Calculate the number of additional requests that could have been handled
+  var totalTime = this.simulationParameters['backendCount'] * this.simulationParameters['backendInFlight'] * this.duration(),
+      potentialResponses = totalTime / this.simulationParameters['backendProcessingTime'];
+  return potentialResponses - responseCount;
+}
+
+Simulation.prototype.scoreSimulation = function () {
+  console.log("Scoring now");
+  var resultsPath = this.resultsPath,
+      roundScores = this.simulationResults.map(this.scoreRound.bind(this)),
+      goodCount = util.sum(roundScores),
+      backendDeficit = this.calculateDowntime(this.responseTotal);
+
+  var output = {
+    "good_responses": goodCount,
+    "backend_deficit": backendDeficit,
+    "correct": true
+  };
+  console.log("Number of total responses %s", this.responseTotal)
+  console.log("Number of good responses: %s", goodCount);
+  console.log("Number of responses less than ideal: %s", backendDeficit);
+  fs.writeFileSync(resultsPath, JSON.stringify(output));
+  process.exit();
+};
+
+function main() {
+  var opts = {
+    "secret": String,
+    "out-socket": String,
+    "out-port": String,
+    "check-server": Boolean,
+    "debug": Boolean,
+    "results-path": String,
+    "run-time": Number
+  };
+  var parsed = nopt(opts),
+      resultsPath = parsed['results-path'] || path.resolve(__dirname, "results.json"),
+      secret = parsed.secret || "defaultsecret",
+      secretHash = util.hash(secret),
+      connectionOptions,
+      seed,
+      simulationParameters;
+
+  if (parsed['out-socket'] !== undefined && parsed['out-port'] !== undefined) {
+    console.log("Cannot specify both an out-port and an out-socket. Exiting.");
+    process.exit(1);
+  } else if (parsed['out-socket']) {
+    connectionOptions = {'socketPath': parsed['out-socket']};
+  } else {
+    connectionOptions = {
+      'host': 'localhost',
+      'port':  parsed['out-port'] || '3000'
+    };
+  }
+  connectionOptions['path'] = "/" + secretHash;
+
+  if (parsed.argv.remain.length > 1) {
+    console.log("Expected at most one extra arg and received more. Exiting.");
+  }
+  seed = parsed.argv.remain[0] || util.generateRandom(32);
+  console.log("Using seed %s", seed);
+
+  simulationParameters = {
+    'clientLifetime': 2, // In rounds
+    'roundLength': 500, // In ms
+    'roundCount': 40,
+    'clientsPerRound': 5,
+    'pElephant': 0.4,
+    'mouseRequestsPerRound': 2,
+    'elephantRequestsPerRound': 50,
+    'backendCount': 2,
+    'backendInFlight': 2,
+    'backendProcessingTime': 75
+  };
+
+  if (parsed['run-time']) {
+    simulationParameters.roundCount = Math.floor(
+      parsed['run-time'] * 1000 / simulationParameters.roundLength);
+  }
+
+  var simulation = new Simulation(seed, simulationParameters);
+  simulation.connection = connectionOptions;
+  simulation.resultsPath = resultsPath;
+  simulation.debugOutput = parsed['debug'];
+  simulation.secret = secret;
+
+  checkServer.checkWithBackoff(
+    connectionOptions,
+    function () {
+      if (parsed['check-server']) {
+        // Just check that the server is up.
+        console.log("Server is up.");
+        process.exit(0);
+      } else {
+        simulation.runSimulation();
+      }
+    },
+    function () {
+      console.log("Server is not up. Exiting.");
+      process.exit(1);
+    }
+  );
+}
+
+main();

@@ -0,0 +1,1 @@
+../nopt/bin/nopt.js
\ No newline at end of file

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+var nopt = require("../lib/nopt")
+  , types = { num: Number
+            , bool: Boolean
+            , help: Boolean
+            , list: Array
+            , "num-list": [Number, Array]
+            , "str-list": [String, Array]
+            , "bool-list": [Boolean, Array]
+            , str: String
+            , clear: Boolean
+            , config: Boolean
+            , length: Number
+            }
+  , shorthands = { s: [ "--str", "astring" ]
+                 , b: [ "--bool" ]
+                 , nb: [ "--no-bool" ]
+                 , tft: [ "--bool-list", "--no-bool-list", "--bool-list", "true" ]
+                 , "?": ["--help"]
+                 , h: ["--help"]
+                 , H: ["--help"]
+                 , n: [ "--num", "125" ]
+                 , c: ["--config"]
+                 , l: ["--length"]
+                 }
+  , parsed = nopt( types
+                 , shorthands
+                 , process.argv
+                 , 2 )
+
+console.log("parsed", parsed)
+
+if (parsed.help) {
+  console.log("")
+  console.log("nopt cli tester")
+  console.log("")
+  console.log("types")
+  console.log(Object.keys(types).map(function M (t) {
+    var type = types[t]
+    if (Array.isArray(type)) {
+      return [t, type.map(function (type) { return type.name })]
+    }
+    return [t, type && type.name]
+  }).reduce(function (s, i) {
+    s[i[0]] = i[1]
+    return s
+  }, {}))
+  console.log("")
+  console.log("shorthands")
+  console.log(shorthands)
+}

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+//process.env.DEBUG_NOPT = 1
+
+// my-program.js
+var nopt = require("../lib/nopt")
+  , Stream = require("stream").Stream
+  , path = require("path")
+  , knownOpts = { "foo" : [String, null]
+                , "bar" : [Stream, Number]
+                , "baz" : path
+                , "bloo" : [ "big", "medium", "small" ]
+                , "flag" : Boolean
+                , "pick" : Boolean
+                }
+  , shortHands = { "foofoo" : ["--foo", "Mr. Foo"]
+                 , "b7" : ["--bar", "7"]
+                 , "m" : ["--bloo", "medium"]
+                 , "p" : ["--pick"]
+                 , "f" : ["--flag", "true"]
+                 , "g" : ["--flag"]
+                 , "s" : "--flag"
+                 }
+             // everything is optional.
+             // knownOpts and shorthands default to {}
+             // arg list defaults to process.argv
+             // slice defaults to 2
+  , parsed = nopt(knownOpts, shortHands, process.argv, 2)
+
+console.log("parsed =\n"+ require("util").inspect(parsed))

@@ -0,0 +1,612 @@
+// info about each config option.
+
+var debug = process.env.DEBUG_NOPT || process.env.NOPT_DEBUG
+  ? function () { console.error.apply(console, arguments) }
+  : function () {}
+
+var url = require("url")
+  , path = require("path")
+  , Stream = require("stream").Stream
+  , abbrev = require("abbrev")
+
+module.exports = exports = nopt
+exports.clean = clean
+
+exports.typeDefs =
+  { String  : { type: String,  validate: validateString  }
+  , Boolean : { type: Boolean, validate: validateBoolean }
+  , url     : { type: url,     validate: validateUrl     }
+  , Number  : { type: Number,  validate: validateNumber  }
+  , path    : { type: path,    validate: validatePath    }
+  , Stream  : { type: Stream,  validate: validateStream  }
+  , Date    : { type: Date,    validate: validateDate    }
+  }
+
+function nopt (types, shorthands, args, slice) {
+  args = args || process.argv
+  types = types || {}
+  shorthands = shorthands || {}
+  if (typeof slice !== "number") slice = 2
+
+  debug(types, shorthands, args, slice)
+
+  args = args.slice(slice)
+  var data = {}
+    , key
+    , remain = []
+    , cooked = args
+    , original = args.slice(0)
+
+  parse(args, data, remain, types, shorthands)
+  // now data is full
+  clean(data, types, exports.typeDefs)
+  data.argv = {remain:remain,cooked:cooked,original:original}
+  Object.defineProperty(data.argv, 'toString', { value: function () {
+    return this.original.map(JSON.stringify).join(" ")
+  }, enumerable: false })
+  return data
+}
+
+function clean (data, types, typeDefs) {
+  typeDefs = typeDefs || exports.typeDefs
+  var remove = {}
+    , typeDefault = [false, true, null, String, Number, Array]
+
+  Object.keys(data).forEach(function (k) {
+    if (k === "argv") return
+    var val = data[k]
+      , isArray = Array.isArray(val)
+      , type = types[k]
+    if (!isArray) val = [val]
+    if (!type) type = typeDefault
+    if (type === Array) type = typeDefault.concat(Array)
+    if (!Array.isArray(type)) type = [type]
+
+    debug("val=%j", val)
+    debug("types=", type)
+    val = val.map(function (val) {
+      // if it's an unknown value, then parse false/true/null/numbers/dates
+      if (typeof val === "string") {
+        debug("string %j", val)
+        val = val.trim()
+        if ((val === "null" && ~type.indexOf(null))
+            || (val === "true" &&
+               (~type.indexOf(true) || ~type.indexOf(Boolean)))
+            || (val === "false" &&
+               (~type.indexOf(false) || ~type.indexOf(Boolean)))) {
+          val = JSON.parse(val)
+          debug("jsonable %j", val)
+        } else if (~type.indexOf(Number) && !isNaN(val)) {
+          debug("convert to number", val)
+          val = +val
+        } else if (~type.indexOf(Date) && !isNaN(Date.parse(val))) {
+          debug("convert to date", val)
+          val = new Date(val)
+        }
+      }
+
+      if (!types.hasOwnProperty(k)) {
+        return val
+      }
+
+      // allow `--no-blah` to set 'blah' to null if null is allowed
+      if (val === false && ~type.indexOf(null) &&
+          !(~type.indexOf(false) || ~type.indexOf(Boolean))) {
+        val = null
+      }
+
+      var d = {}
+      d[k] = val
+      debug("prevalidated val", d, val, types[k])
+      if (!validate(d, k, val, types[k], typeDefs)) {
+        if (exports.invalidHandler) {
+          exports.invalidHandler(k, val, types[k], data)
+        } else if (exports.invalidHandler !== false) {
+          debug("invalid: "+k+"="+val, types[k])
+        }
+        return remove
+      }
+      debug("validated val", d, val, types[k])
+      return d[k]
+    }).filter(function (val) { return val !== remove })
+
+    if (!val.length) delete data[k]
+    else if (isArray) {
+      debug(isArray, data[k], val)
+      data[k] = val
+    } else data[k] = val[0]
+
+    debug("k=%s val=%j", k, val, data[k])
+  })
+}
+
+function validateString (data, k, val) {
+  data[k] = String(val)
+}
+
+function validatePath (data, k, val) {
+  data[k] = path.resolve(String(val))
+  return true
+}
+
+function validateNumber (data, k, val) {
+  debug("validate Number %j %j %j", k, val, isNaN(val))
+  if (isNaN(val)) return false
+  data[k] = +val
+}
+
+function validateDate (data, k, val) {
+  debug("validate Date %j %j %j", k, val, Date.parse(val))
+  var s = Date.parse(val)
+  if (isNaN(s)) return false
+  data[k] = new Date(val)
+}
+
+function validateBoolean (data, k, val) {
+  if (val instanceof Boolean) val = val.valueOf()
+  else if (typeof val === "string") {
+    if (!isNaN(val)) val = !!(+val)
+    else if (val === "null" || val === "false") val = false
+    else val = true
+  } else val = !!val
+  data[k] = val
+}
+
+function validateUrl (data, k, val) {
+  val = url.parse(String(val))
+  if (!val.host) return false
+  data[k] = val.href
+}
+
+function validateStream (data, k, val) {
+  if (!(val instanceof Stream)) return false
+  data[k] = val
+}
+
+function validate (data, k, val, type, typeDefs) {
+  // arrays are lists of types.
+  if (Array.isArray(type)) {
+    for (var i = 0, l = type.length; i < l; i ++) {
+      if (type[i] === Array) continue
+      if (validate(data, k, val, type[i], typeDefs)) return true
+    }
+    delete data[k]
+    return false
+  }
+
+  // an array of anything?
+  if (type === Array) return true
+
+  // NaN is poisonous.  Means that something is not allowed.
+  if (type !== type) {
+    debug("Poison NaN", k, val, type)
+    delete data[k]
+    return false
+  }
+
+  // explicit list of values
+  if (val === type) {
+    debug("Explicitly allowed %j", val)
+    // if (isArray) (data[k] = data[k] || []).push(val)
+    // else data[k] = val
+    data[k] = val
+    return true
+  }
+
+  // now go through the list of typeDefs, validate against each one.
+  var ok = false
+    , types = Object.keys(typeDefs)
+  for (var i = 0, l = types.length; i < l; i ++) {
+    debug("test type %j %j %j", k, val, types[i])
+    var t = typeDefs[types[i]]
+    if (t && type === t.type) {
+      var d = {}
+      ok = false !== t.validate(d, k, val)
+      val = d[k]
+      if (ok) {
+        // if (isArray) (data[k] = data[k] || []).push(val)
+        // else data[k] = val
+        data[k] = val
+        break
+      }
+    }
+  }
+  debug("OK? %j (%j %j %j)", ok, k, val, types[i])
+
+  if (!ok) delete data[k]
+  return ok
+}
+
+function parse (args, data, remain, types, shorthands) {
+  debug("parse", args, data, remain)
+
+  var key = null
+    , abbrevs = abbrev(Object.keys(types))
+    , shortAbbr = abbrev(Object.keys(shorthands))
+
+  for (var i = 0; i < args.length; i ++) {
+    var arg = args[i]
+    debug("arg", arg)
+
+    if (arg.match(/^-{2,}$/)) {
+      // done with keys.
+      // the rest are args.
+      remain.push.apply(remain, args.slice(i + 1))
+      args[i] = "--"
+      break
+    }
+    var hadEq = false
+    if (arg.charAt(0) === "-" && arg.length > 1) {
+      if (arg.indexOf("=") !== -1) {
+        hadEq = true
+        var v = arg.split("=")
+        arg = v.shift()
+        v = v.join("=")
+        args.splice.apply(args, [i, 1].concat([arg, v]))
+      }
+
+      // see if it's a shorthand
+      // if so, splice and back up to re-parse it.
+      var shRes = resolveShort(arg, shorthands, shortAbbr, abbrevs)
+      debug("arg=%j shRes=%j", arg, shRes)
+      if (shRes) {
+        debug(arg, shRes)
+        args.splice.apply(args, [i, 1].concat(shRes))
+        if (arg !== shRes[0]) {
+          i --
+          continue
+        }
+      }
+      arg = arg.replace(/^-+/, "")
+      var no = null
+      while (arg.toLowerCase().indexOf("no-") === 0) {
+        no = !no
+        arg = arg.substr(3)
+      }
+
+      if (abbrevs[arg]) arg = abbrevs[arg]
+
+      var isArray = types[arg] === Array ||
+        Array.isArray(types[arg]) && types[arg].indexOf(Array) !== -1
+
+      // allow unknown things to be arrays if specified multiple times.
+      if (!types.hasOwnProperty(arg) && data.hasOwnProperty(arg)) {
+        if (!Array.isArray(data[arg]))
+          data[arg] = [data[arg]]
+        isArray = true
+      }
+
+      var val
+        , la = args[i + 1]
+
+      var isBool = typeof no === 'boolean' ||
+        types[arg] === Boolean ||
+        Array.isArray(types[arg]) && types[arg].indexOf(Boolean) !== -1 ||
+        (typeof types[arg] === 'undefined' && !hadEq) ||
+        (la === "false" &&
+         (types[arg] === null ||
+          Array.isArray(types[arg]) && ~types[arg].indexOf(null)))
+
+      if (isBool) {
+        // just set and move along
+        val = !no
+        // however, also support --bool true or --bool false
+        if (la === "true" || la === "false") {
+          val = JSON.parse(la)
+          la = null
+          if (no) val = !val
+          i ++
+        }
+
+        // also support "foo":[Boolean, "bar"] and "--foo bar"
+        if (Array.isArray(types[arg]) && la) {
+          if (~types[arg].indexOf(la)) {
+            // an explicit type
+            val = la
+            i ++
+          } else if ( la === "null" && ~types[arg].indexOf(null) ) {
+            // null allowed
+            val = null
+            i ++
+          } else if ( !la.match(/^-{2,}[^-]/) &&
+                      !isNaN(la) &&
+                      ~types[arg].indexOf(Number) ) {
+            // number
+            val = +la
+            i ++
+          } else if ( !la.match(/^-[^-]/) && ~types[arg].indexOf(String) ) {
+            // string
+            val = la
+            i ++
+          }
+        }
+
+        if (isArray) (data[arg] = data[arg] || []).push(val)
+        else data[arg] = val
+
+        continue
+      }
+
+      if (la && la.match(/^-{2,}$/)) {
+        la = undefined
+        i --
+      }
+
+      val = la === undefined ? true : la
+      if (isArray) (data[arg] = data[arg] || []).push(val)
+      else data[arg] = val
+
+      i ++
+      continue
+    }
+    remain.push(arg)
+  }
+}
+
+function resolveShort (arg, shorthands, shortAbbr, abbrevs) {
+  // handle single-char shorthands glommed together, like
+  // npm ls -glp, but only if there is one dash, and only if
+  // all of the chars are single-char shorthands, and it's
+  // not a match to some other abbrev.
+  arg = arg.replace(/^-+/, '')
+
+  // if it's an exact known option, then don't go any further
+  if (abbrevs[arg] === arg)
+    return null
+
+  // if it's an exact known shortopt, same deal
+  if (shorthands[arg]) {
+    // make it an array, if it's a list of words
+    if (shorthands[arg] && !Array.isArray(shorthands[arg]))
+      shorthands[arg] = shorthands[arg].split(/\s+/)
+
+    return shorthands[arg]
+  }
+
+  // first check to see if this arg is a set of single-char shorthands
+  var singles = shorthands.___singles
+  if (!singles) {
+    singles = Object.keys(shorthands).filter(function (s) {
+      return s.length === 1
+    }).reduce(function (l,r) {
+      l[r] = true
+      return l
+    }, {})
+    shorthands.___singles = singles
+    debug('shorthand singles', singles)
+  }
+
+  var chrs = arg.split("").filter(function (c) {
+    return singles[c]
+  })
+
+  if (chrs.join("") === arg) return chrs.map(function (c) {
+    return shorthands[c]
+  }).reduce(function (l, r) {
+    return l.concat(r)
+  }, [])
+
+
+  // if it's an arg abbrev, and not a literal shorthand, then prefer the arg
+  if (abbrevs[arg] && !shorthands[arg])
+    return null
+
+  // if it's an abbr for a shorthand, then use that
+  if (shortAbbr[arg])
+    arg = shortAbbr[arg]
+
+  // make it an array, if it's a list of words
+  if (shorthands[arg] && !Array.isArray(shorthands[arg]))
+    shorthands[arg] = shorthands[arg].split(/\s+/)
+
+  return shorthands[arg]
+}
+
+if (module === require.main) {
+var assert = require("assert")
+  , util = require("util")
+
+  , shorthands =
+    { s : ["--loglevel", "silent"]
+    , d : ["--loglevel", "info"]
+    , dd : ["--loglevel", "verbose"]
+    , ddd : ["--loglevel", "silly"]
+    , noreg : ["--no-registry"]
+    , reg : ["--registry"]
+    , "no-reg" : ["--no-registry"]
+    , silent : ["--loglevel", "silent"]
+    , verbose : ["--loglevel", "verbose"]
+    , h : ["--usage"]
+    , H : ["--usage"]
+    , "?" : ["--usage"]
+    , help : ["--usage"]
+    , v : ["--version"]
+    , f : ["--force"]
+    , desc : ["--description"]
+    , "no-desc" : ["--no-description"]
+    , "local" : ["--no-global"]
+    , l : ["--long"]
+    , p : ["--parseable"]
+    , porcelain : ["--parseable"]
+    , g : ["--global"]
+    }
+
+  , types =
+    { aoa: Array
+    , nullstream: [null, Stream]
+    , date: Date
+    , str: String
+    , browser : String
+    , cache : path
+    , color : ["always", Boolean]
+    , depth : Number
+    , description : Boolean
+    , dev : Boolean
+    , editor : path
+    , force : Boolean
+    , global : Boolean
+    , globalconfig : path
+    , group : [String, Number]
+    , gzipbin : String
+    , logfd : [Number, Stream]
+    , loglevel : ["silent","win","error","warn","info","verbose","silly"]
+    , long : Boolean
+    , "node-version" : [false, String]
+    , npaturl : url
+    , npat : Boolean
+    , "onload-script" : [false, String]
+    , outfd : [Number, Stream]
+    , parseable : Boolean
+    , pre: Boolean
+    , prefix: path
+    , proxy : url
+    , "rebuild-bundle" : Boolean
+    , registry : url
+    , searchopts : String
+    , searchexclude: [null, String]
+    , shell : path
+    , t: [Array, String]
+    , tag : String
+    , tar : String
+    , tmp : path
+    , "unsafe-perm" : Boolean
+    , usage : Boolean
+    , user : String
+    , username : String
+    , userconfig : path
+    , version : Boolean
+    , viewer: path
+    , _exit : Boolean
+    }
+
+; [["-v", {version:true}, []]
+  ,["---v", {version:true}, []]
+  ,["ls -s --no-reg connect -d",
+    {loglevel:"info",registry:null},["ls","connect"]]
+  ,["ls ---s foo",{loglevel:"silent"},["ls","foo"]]
+  ,["ls --registry blargle", {}, ["ls"]]
+  ,["--no-registry", {registry:null}, []]
+  ,["--no-color true", {color:false}, []]
+  ,["--no-color false", {color:true}, []]
+  ,["--no-color", {color:false}, []]
+  ,["--color false", {color:false}, []]
+  ,["--color --logfd 7", {logfd:7,color:true}, []]
+  ,["--color=true", {color:true}, []]
+  ,["--logfd=10", {logfd:10}, []]
+  ,["--tmp=/tmp -tar=gtar",{tmp:"/tmp",tar:"gtar"},[]]
+  ,["--tmp=tmp -tar=gtar",
+    {tmp:path.resolve(process.cwd(), "tmp"),tar:"gtar"},[]]
+  ,["--logfd x", {}, []]
+  ,["a -true -- -no-false", {true:true},["a","-no-false"]]
+  ,["a -no-false", {false:false},["a"]]
+  ,["a -no-no-true", {true:true}, ["a"]]
+  ,["a -no-no-no-false", {false:false}, ["a"]]
+  ,["---NO-no-No-no-no-no-nO-no-no"+
+    "-No-no-no-no-no-no-no-no-no"+
+    "-no-no-no-no-NO-NO-no-no-no-no-no-no"+
+    "-no-body-can-do-the-boogaloo-like-I-do"
+   ,{"body-can-do-the-boogaloo-like-I-do":false}, []]
+  ,["we are -no-strangers-to-love "+
+    "--you-know=the-rules --and=so-do-i "+
+    "---im-thinking-of=a-full-commitment "+
+    "--no-you-would-get-this-from-any-other-guy "+
+    "--no-gonna-give-you-up "+
+    "-no-gonna-let-you-down=true "+
+    "--no-no-gonna-run-around false "+
+    "--desert-you=false "+
+    "--make-you-cry false "+
+    "--no-tell-a-lie "+
+    "--no-no-and-hurt-you false"
+   ,{"strangers-to-love":false
+    ,"you-know":"the-rules"
+    ,"and":"so-do-i"
+    ,"you-would-get-this-from-any-other-guy":false
+    ,"gonna-give-you-up":false
+    ,"gonna-let-you-down":false
+    ,"gonna-run-around":false
+    ,"desert-you":false
+    ,"make-you-cry":false
+    ,"tell-a-lie":false
+    ,"and-hurt-you":false
+    },["we", "are"]]
+  ,["-t one -t two -t three"
+   ,{t: ["one", "two", "three"]}
+   ,[]]
+  ,["-t one -t null -t three four five null"
+   ,{t: ["one", "null", "three"]}
+   ,["four", "five", "null"]]
+  ,["-t foo"
+   ,{t:["foo"]}
+   ,[]]
+  ,["--no-t"
+   ,{t:["false"]}
+   ,[]]
+  ,["-no-no-t"
+   ,{t:["true"]}
+   ,[]]
+  ,["-aoa one -aoa null -aoa 100"
+   ,{aoa:["one", null, 100]}
+   ,[]]
+  ,["-str 100"
+   ,{str:"100"}
+   ,[]]
+  ,["--color always"
+   ,{color:"always"}
+   ,[]]
+  ,["--no-nullstream"
+   ,{nullstream:null}
+   ,[]]
+  ,["--nullstream false"
+   ,{nullstream:null}
+   ,[]]
+  ,["--notadate=2011-01-25"
+   ,{notadate: "2011-01-25"}
+   ,[]]
+  ,["--date 2011-01-25"
+   ,{date: new Date("2011-01-25")}
+   ,[]]
+  ,["-cl 1"
+   ,{config: true, length: 1}
+   ,[]
+   ,{config: Boolean, length: Number, clear: Boolean}
+   ,{c: "--config", l: "--length"}]
+  ,["--acount bla"
+   ,{"acount":true}
+   ,["bla"]
+   ,{account: Boolean, credentials: Boolean, options: String}
+   ,{a:"--account", c:"--credentials",o:"--options"}]
+  ,["--clear"
+   ,{clear:true}
+   ,[]
+   ,{clear:Boolean,con:Boolean,len:Boolean,exp:Boolean,add:Boolean,rep:Boolean}
+   ,{c:"--con",l:"--len",e:"--exp",a:"--add",r:"--rep"}]
+  ,["--file -"
+   ,{"file":"-"}
+   ,[]
+   ,{file:String}
+   ,{}]
+  ,["--file -"
+   ,{"file":true}
+   ,["-"]
+   ,{file:Boolean}
+   ,{}]
+  ].forEach(function (test) {
+    var argv = test[0].split(/\s+/)
+      , opts = test[1]
+      , rem = test[2]
+      , actual = nopt(test[3] || types, test[4] || shorthands, argv, 0)
+      , parsed = actual.argv
+    delete actual.argv
+    console.log(util.inspect(actual, false, 2, true), parsed.remain)
+    for (var i in opts) {
+      var e = JSON.stringify(opts[i])
+        , a = JSON.stringify(actual[i] === undefined ? null : actual[i])
+      if (e && typeof e === "object") {
+        assert.deepEqual(e, a)
+      } else {
+        assert.equal(e, a)
+      }
+    }
+    assert.deepEqual(rem, parsed.remain)
+  })
+}