vulcan 0.6.1 → 0.7.0

data/server/node_modules/cradle/node_modules/follow/node_modules/request/vendor/cookie/index.js

@@ -0,0 +1,55 @@
+/*!
+ * Tobi - Cookie
+ * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var url = require('url');
+
+/**
+ * Initialize a new `Cookie` with the given cookie `str` and `req`.
+ *
+ * @param {String} str
+ * @param {IncomingRequest} req
+ * @api private
+ */
+
+var Cookie = exports = module.exports = function Cookie(str, req) {
+  this.str = str;
+
+  // First key is the name
+  this.name = str.substr(0, str.indexOf('='));
+
+  // Map the key/val pairs
+  str.split(/ *; */).reduce(function(obj, pair){
+    pair = pair.split(/ *= */);
+    obj[pair[0].toLowerCase()] = pair[1] || true;
+    return obj;
+  }, this);
+
+  // Assign value
+  this.value = this[this.name];
+
+  // Expires
+  this.expires = this.expires
+    ? new Date(this.expires)
+    : Infinity;
+
+  // Default or trim path
+  this.path = this.path || '/';
+};
+
+/**
+ * Return the original cookie string.
+ *
+ * @return {String}
+ * @api public
+ */
+
+Cookie.prototype.toString = function(){
+  return this.str;
+};

data/server/node_modules/cradle/node_modules/follow/node_modules/request/vendor/cookie/jar.js

@@ -0,0 +1,72 @@
+/*!
+* Tobi - CookieJar
+* Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+* MIT Licensed
+*/
+
+/**
+* Module dependencies.
+*/
+
+var url = require('url');
+
+/**
+* Initialize a new `CookieJar`.
+*
+* @api private
+*/
+
+var CookieJar = exports = module.exports = function CookieJar() {
+  this.cookies = [];
+};
+
+/**
+* Add the given `cookie` to the jar.
+*
+* @param {Cookie} cookie
+* @api private
+*/
+
+CookieJar.prototype.add = function(cookie){
+  this.cookies = this.cookies.filter(function(c){
+    // Avoid duplication (same path, same name)
+    return !(c.name == cookie.name && c.path == cookie.path);
+  });
+  this.cookies.push(cookie);
+};
+
+/**
+* Get cookies for the given `req`.
+*
+* @param {IncomingRequest} req
+* @return {Array}
+* @api private
+*/
+
+CookieJar.prototype.get = function(req){
+  var path = url.parse(req.url).pathname
+    , now = new Date
+    , specificity = {};
+  return this.cookies.filter(function(cookie){
+    if (0 == path.indexOf(cookie.path) && now < cookie.expires
+      && cookie.path.length > (specificity[cookie.name] || 0))
+      return specificity[cookie.name] = cookie.path.length;
+  });
+};
+
+/**
+* Return Cookie string for the given `req`.
+*
+* @param {IncomingRequest} req
+* @return {String}
+* @api private
+*/
+
+CookieJar.prototype.cookieString = function(req){
+  var cookies = this.get(req);
+  if (cookies.length) {
+    return cookies.map(function(cookie){
+      return cookie.name + '=' + cookie.value;
+    }).join('; ');
+  }
+};

data/server/node_modules/cradle/node_modules/follow/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "follow",
+  "version": "0.7.2",
+  "author": {
+    "name": "Jason Smith",
+    "email": "jhs@iriscouch.com"
+  },
+  "description": "Extremely robust, fault-tolerant CouchDB changes follower",
+  "keywords": [
+    "couchdb",
+    "changes",
+    "sleep",
+    "sleepy"
+  ],
+  "homepage": "http://github.com/iriscouch/follow",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/iriscouch/follow.git"
+  },
+  "engines": [
+    "node"
+  ],
+  "dependencies": {
+    "request": "~2.2.5"
+  },
+  "devDependencies": {
+    "tap": "~0.1.3",
+    "traceback": "~0.3.0"
+  },
+  "main": "./api.js",
+  "bin": {
+    "follow": "./cli.js"
+  },
+  "_npmUser": {
+    "name": "ddollar",
+    "email": "ddollar@gmail.com"
+  },
+  "_id": "follow@0.7.2",
+  "optionalDependencies": {},
+  "_engineSupported": true,
+  "_npmVersion": "1.1.21",
+  "_nodeVersion": "v0.6.17",
+  "_defaultsLoaded": true,
+  "_from": "follow@0.7.x"
+}

data/server/node_modules/cradle/node_modules/follow/test/couch.js

@@ -0,0 +1,153 @@
+// CouchDB tests
+//
+// This module is also a library for other test modules.
+
+var tap = require('tap')
+  , util = require('util')
+  , assert = require('assert')
+  , request = require('request')
+
+var follow = require('../api')
+  , DB = process.env.db || 'http://localhost:5984/follow_test'
+  , RTT = null
+
+
+module.exports = { 'DB': DB
+                 , 'rtt' : get_rtt
+                 , 'redo': redo_couch
+                 , 'setup': setup_test
+                 , 'make_data': make_data
+                 }
+
+
+function get_rtt() {
+  if(!RTT)
+    throw new Error('RTT was not set. Use setup(test) or redo(callback)')
+  return RTT
+}
+
+
+// Basically a redo but testing along the way.
+function setup_test(test_func) {
+  assert.equal(typeof test_func, 'function', 'Please provide tap.test function')
+
+  test_func('Initialize CouchDB', function(t) {
+    init_db(t, function(er, rtt) {
+      RTT = rtt
+      t.end()
+    })
+  })
+}
+
+function redo_couch(callback) {
+  function noop() {}
+  var t = { 'ok':noop, 'false':noop, 'equal':noop, 'end':noop }
+  init_db(t, function(er, rtt) {
+    if(rtt)
+      RTT = rtt
+    return callback(er)
+  })
+}
+
+function init_db(t, callback) {
+  var create_begin = new Date
+
+  request.del({uri:DB, json:true}, function(er, res) {
+    t.false(er, 'Clear old test DB: ' + DB)
+    t.ok(!res.body.error || res.body.error == 'not_found', 'Couch cleared old test DB: ' + DB)
+
+    request.put({uri:DB, json:true}, function(er, res) {
+      t.false(er, 'Create new test DB: ' + DB)
+      t.false(res.body.error, 'Couch created new test DB: ' + DB)
+
+      var values = ['first', 'second', 'third']
+        , stores = 0
+      values.forEach(function(val) {
+        var doc = { _id:'doc_'+val, value:val }
+
+        request.post({uri:DB, json:doc}, function(er, res) {
+          t.false(er, 'POST document')
+          t.equal(res.statusCode, 201, 'Couch stored test document')
+
+          stores += 1
+          if(stores == values.length) {
+            var rtt = (new Date) - create_begin
+            callback(null, rtt)
+            //request.post({uri:DB, json:{_id:'_local/rtt', ms:(new Date)-begin}}, function(er, res) {
+            //  t.false(er, 'Store RTT value')
+            //  t.equal(res.statusCode, 201, 'Couch stored RTT value')
+            //  t.end()
+            //})
+          }
+        })
+      })
+    })
+  })
+}
+
+
+function make_data(minimum_size, callback) {
+  var payload = {'docs':[]}
+    , size = 0
+
+  // TODO: Make document number 20 really large, at least over 9kb.
+  while(size < minimum_size) {
+    var doc = {}
+      , key_count = rndint(0, 25)
+
+    while(key_count-- > 0)
+      doc[rndstr(8)] = rndstr(20)
+
+    // The 20th document has one really large string value.
+    if(payload.docs.length == 19) {
+      var big_str = rndstr(9000, 15000)
+      doc.big = {'length':big_str.length, 'value':big_str}
+    }
+
+    size += JSON.stringify(doc).length // This is an underestimate because an _id and _rev will be added.
+    payload.docs.push(doc)
+  }
+
+  request.post({'uri':DB+'/_bulk_docs', 'json':payload}, function(er, res) {
+    if(er) throw er
+
+    if(res.statusCode != 201)
+      throw new Error('Bad bulk_docs update: ' + util.inspect(res.body))
+
+    if(res.body.length != payload.docs.length)
+      throw new Error('Should have results for '+payload.docs.length+' doc insertions')
+
+    if(res.body.length < 1500)
+      throw new Error('Seems like at least 1,500 docs should have been added: ' + res.body.length)
+
+    res.body.forEach(function(result) {
+      if(!result || !result.id || !result.rev)
+        throw new Error('Bad bulk_docs response: ' + util.inspect(result))
+    })
+
+    return callback(payload.docs.length)
+  })
+
+  function rndstr(minlen, maxlen) {
+    if(!maxlen) {
+      maxlen = minlen
+      minlen = 1
+    }
+
+    var str = ""
+      , length = rndint(minlen, maxlen)
+
+    while(length-- > 0)
+      str += String.fromCharCode(rndint(97, 122))
+
+    return str
+  }
+
+  function rndint(min, max) {
+    return min + Math.floor(Math.random() * (max - min + 1))
+  }
+}
+
+
+if(require.main === module)
+  setup_test(tap.test)

data/server/node_modules/cradle/node_modules/follow/test/follow.js

@@ -0,0 +1,136 @@
+var tap = require('tap')
+  , test = tap.test
+  , util = require('util')
+  , request = require('request')
+
+var couch = require('./couch')
+  , follow = require('../api')
+
+
+couch.setup(test)
+
+test('Follow API', function(t) {
+  var i = 0
+    , saw = {}
+
+  var feed = follow(couch.DB, function(er, change) {
+    t.is(this, feed, 'Callback "this" value is the feed object')
+
+    i += 1
+    t.false(er, 'No error coming back from follow: ' + i)
+    t.equal(change.seq, i, 'Change #'+i+' should have seq_id='+i)
+    saw[change.id] = true
+
+    if(i == 3) {
+      t.ok(saw.doc_first, 'Got the first document')
+      t.ok(saw.doc_second, 'Got the second document')
+      t.ok(saw.doc_third , 'Got the third document')
+
+      t.doesNotThrow(function() { feed.stop() }, 'No problem calling stop()')
+
+      t.end()
+    }
+  })
+})
+
+test("Confirmation request behavior", function(t) {
+  var feed = follow(couch.DB, function() {})
+
+  var confirm_req = null
+    , follow_req = null
+
+  feed.on('confirm_request', function(req) { confirm_req = req })
+  feed.on('query', function(req) { follow_req = req })
+
+  setTimeout(check_req, couch.rtt() * 2)
+  function check_req() {
+    t.ok(confirm_req, 'The confirm_request event should have fired by now')
+    t.ok(confirm_req.agent, 'The confirm request has an agent')
+
+    t.ok(follow_req, 'The follow_request event should have fired by now')
+    t.ok(follow_req.agent, 'The follow request has an agent')
+
+    // Confirm that the changes follower is not still in the pool.
+    var host = 'localhost:5984'
+    follow_req.req.agent.sockets[host].forEach(function(socket, i) {
+      t.isNot(socket, follow_req.req.connection, 'The changes follower is not socket '+i+' in the agent pool')
+    })
+
+    feed.stop()
+    t.end()
+  }
+})
+
+test('Heartbeats', function(t) {
+  t.ok(couch.rtt(), 'The couch RTT is known')
+  var check_time = couch.rtt() * 3.5 // Enough time for 3 heartbeats.
+
+  var beats = 0
+    , retries = 0
+
+  var feed = follow(couch.DB, function() {})
+  feed.heartbeat = couch.rtt()
+  feed.on('response', function() { feed.retry_delay = 1 })
+
+  feed.on('heartbeat', function() { beats += 1 })
+  feed.on('retry', function() { retries += 1 })
+
+  feed.on('catchup', function() {
+    t.equal(beats, 0, 'Still 0 heartbeats after receiving changes')
+    t.equal(retries, 0, 'Still 0 retries after receiving changes')
+
+    //console.error('Waiting ' + couch.rtt() + ' * 3 = ' + check_time + ' to check stuff')
+    setTimeout(check_counters, check_time)
+    function check_counters() {
+      t.equal(beats, 3, 'Three heartbeats ('+couch.rtt()+') fired after '+check_time+' ms')
+      t.equal(retries, 0, 'No retries after '+check_time+' ms')
+
+      feed.stop()
+      t.end()
+    }
+  })
+})
+
+test('Events for DB confirmation and hitting the original seq', function(t) {
+  var feed = follow(couch.DB, on_change)
+
+  var events = { 'confirm':null, 'catchup':null }
+  feed.on('confirm', function(db) { events.confirm = db })
+  feed.on('catchup', function(seq) { events.catchup = seq })
+
+  function on_change(er, ch) {
+    t.false(er, 'No problem with the feed')
+    if(ch.seq == 3) {
+      t.ok(events.confirm, 'Confirm event fired')
+      t.equal(events.confirm && events.confirm.db_name, 'follow_test', 'Confirm event returned the Couch DB object')
+      t.equal(events.confirm && events.confirm.update_seq, 3, 'Confirm event got the update_seq right')
+
+      t.ok(events.catchup, 'Catchup event fired')
+      t.equal(events.catchup, 3, 'Catchup event fired on update 3')
+
+      feed.stop()
+      t.end()
+    }
+  }
+})
+
+test('Handle a deleted database', function(t) {
+  var feed = follow(couch.DB, function(er, change) {
+    if(er)
+      return t.equal(er.last_seq, 3, 'Got an error for the deletion event')
+
+    if(change.seq < 3)
+      return
+
+    t.equal(change.seq, 3, 'Got change number 3')
+
+    var redo_er
+    couch.redo(function(er) { redo_er = er })
+
+    setTimeout(check_results, couch.rtt() * 2)
+    function check_results() {
+      t.false(er, 'No problem redoing the couch')
+      t.end()
+    }
+  })
+})