')
53 | .addClass('users')
54 | .text('Users: ' + (
55 | names.map(function (name) {
56 | return '[ ' + name
57 | .replace(/\\/g,'\\\\')
58 | .replace(/\[/g,'\\[')
59 | .replace(/\]/g,'\\]')
60 | + ' ]'
61 | }).join(' ')
62 | || '(no users)'
63 | ))
64 | );
65 | });
66 | });
67 | }
68 |
69 | function addLine(elem) {
70 | var div = $('#messages');
71 | div.append(elem);
72 | div.animate({ scrollTop: div.attr('scrollHeight') }, 200);
73 | }
74 |
--------------------------------------------------------------------------------
/test/logging/exception-handlers-test.js:
--------------------------------------------------------------------------------
1 | /*
2 | * exception-handlers-test.js: Exception handlers logging tests for the hook.io module
3 | *
4 | * MIT LICENCE
5 | *
6 | */
7 | 'use strict';
8 |
9 | var vows, fs, assert, winston, Hook, hook, options;
10 |
11 | fs = require('fs');
12 | vows = require('vows');
13 | assert = require('assert');
14 | winston = require('winston');
15 | Hook = require('../../lib/hookio').Hook;
16 |
17 | options = {
18 | port : 5002,
19 | logger : {
20 | exceptionHandlers : {
21 | file : { filename : __dirname + "/err.log" }
22 | },
23 |
24 | handleExceptions : true,
25 | exitOnError : false
26 | }
27 | };
28 |
29 | vows.describe('hook.io/logging/exception-handlers').addBatch({
30 | "Given a hook with logging configuration" : {
31 | topic : function() {
32 | return new Hook(options);
33 | },
34 |
35 | "When a hook is ready" : {
36 | topic: function(hook) {
37 | var self;
38 |
39 | self = this;
40 |
41 | hook.on('hook::ready', function() {
42 | self.callback(null, this._winston);
43 | });
44 |
45 | hook.start();
46 | },
47 |
48 | "It should convert the object into Winston exception handlers" : function(err, hookWinston) {
49 | var types, exceptionHandlers, name, capitalized;
50 |
51 | types = options.logger.exceptionHandlers;
52 | exceptionHandlers = hookWinston.exceptionHandlers;
53 |
54 | for (name in types) {
55 | // capitalize the name
56 | capitalized = name.charAt(0).toUpperCase() + name.substr(1);
57 |
58 | assert.instanceOf(exceptionHandlers[name], winston.transports[capitalized]);
59 | }
60 | }
61 | },
62 |
63 | "When an uncaught exception is thrown" : {
64 | topic: function(hook) {
65 | var self = this;
66 |
67 | // can't really throw an error as vows will catch it,
68 | // so we simulate an uncaught exception
69 | hook._winston._uncaughtException(new Error('This error should be logged'));
70 |
71 | setTimeout(function() {
72 | // we first need to wait for the handler to timeout
73 | fs.readFile(hook.logger.exceptionHandlers.file.filename, 'utf-8', self.callback);
74 | }, 4000);
75 | },
76 |
77 | "It should write to the specified log file" : function(err, data) {
78 | assert.ifError(err);
79 | assert.ok(/This error should be logged/.test(data));
80 |
81 | fs.unlink(options.logger.exceptionHandlers.file.filename);
82 | }
83 | }
84 | }
85 | }).export(module);
86 |
--------------------------------------------------------------------------------
/vendor/dnode/test/error.js:
--------------------------------------------------------------------------------
1 | var dnode = require('../');
2 | var sys = require('sys');
3 | var test = require('tap').test;
4 |
5 | test('errors', function (t) {
6 | t.plan(4);
7 | var port = Math.floor(Math.random() * 40000 + 10000);
8 | var errors = { server : [], client : [] };
9 |
10 | var server = dnode(function (remote, conn) {
11 | conn.on('error', function (err) {
12 | errors.server.push(err);
13 | });
14 |
15 | this.one = function () {
16 | throw 'string throw'
17 | };
18 |
19 | this.two = function () {
20 | undefined.name
21 | };
22 |
23 | this.three = function () {
24 | remote.pow();
25 | };
26 | }).listen(port);
27 |
28 | var ts = setTimeout(function () {
29 | t.fail('server never ended');
30 | }, 5000);
31 |
32 | server.on('end', function () {
33 | clearTimeout(ts);
34 | t.deepEqual(errors.server[0], 'string throw');
35 |
36 | try { undefined.name }
37 | catch (refErr) {
38 | process.nextTick(function () {
39 | t.equal(refErr.message, errors.server[1].message);
40 | t.equal(refErr.type, errors.server[1].type);
41 | t.equal(errors.server.length, 2);
42 | t.end();
43 | });
44 | }
45 | });
46 |
47 | server.on('ready', function () {
48 | var client = dnode(function (client, conn) {
49 | conn.on('error', function (err) {
50 | errors.client.push(err);
51 | });
52 |
53 | conn.on('end', function () {
54 | t.deepEqual(errors.client, [ 'Local error' ]);
55 | });
56 |
57 | this.pow = function () {
58 | throw 'Local error';
59 | };
60 | }).connect(port, function (remote, conn) {
61 | remote.one();
62 | remote.two();
63 | remote.three();
64 |
65 | setTimeout(function () {
66 | conn.end();
67 | server.end();
68 | server.close();
69 | }, 500);
70 | });
71 | });
72 | });
73 |
74 | test('refused', function (t) {
75 | t.plan(2);
76 |
77 | var port = Math.floor(Math.random() * 40000 + 10000);
78 | var client = dnode.connect(port, function (remote, conn) {
79 | assert.fail('should have been refused, very unlikely');
80 | });
81 |
82 | client.on('error', function (err) {
83 | t.equal(err.code, 'ECONNREFUSED');
84 | t.equal(err.syscall, 'connect');
85 | t.end();
86 | });
87 | });
88 |
--------------------------------------------------------------------------------
/vendor/dnode/examples/saturate/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
67 |
68 |
69 |
70 | 0
71 | bytes
72 | transferred
73 |
74 |
75 |
76 | ping X milliseconds
77 |
78 |
79 |
80 | 0 connections
81 |
82 |
83 |
84 |
--------------------------------------------------------------------------------
/test/registry/complex-test.js:
--------------------------------------------------------------------------------
1 | var vows = require('vows'),
2 | assert = require('assert'),
3 | Hook = require('../../lib/hookio').Hook,
4 | macros = require('../helpers/macros');
5 |
6 | // Dummy function for event subscription
7 | var emptyFn = function() {};
8 |
9 | vows.describe('hook.io/registry/complex-test').addBatch({
10 | "When a hook is listening on 5012": {
11 | topic: function() {
12 | var self = this, server = new Hook({ name: 'server', debug:true });
13 |
14 | server.once('hook::ready', self.callback.bind(server, null, server));
15 | server.on('eventBeforeStart', emptyFn);
16 |
17 | server.listen({ "hook-port": 5012 });
18 | },
19 | "and another hook connects": {
20 | topic: function(server) {
21 | server.on('eventAfterStart', emptyFn);
22 | server.on('eventAfterStart', emptyFn);
23 | server.on('eventToBeDestroyed', emptyFn);
24 |
25 | var client = new Hook({ name: 'client', debug:true }), self = this;
26 | client.once('hook::ready', function() {
27 | self.callback(null, server, client);
28 | });
29 | client.on('eventBeforeStart', emptyFn);
30 | client.on('eventToBeDestroyed', emptyFn);
31 |
32 | client.connect({ "hook-port": 5012 });
33 | },
34 | "when my hook registers an event": {
35 | topic: function(server, client) {
36 | client.on('eventAfterStart', emptyFn);
37 | server.off('eventToBeDestroyed', emptyFn);
38 | client.off('eventToBeDestroyed', emptyFn);
39 |
40 | // Register a new "testEvent"
41 | client.on('testEvent', emptyFn);
42 |
43 | // Wait a bit for the event to propagate.
44 | // I'm not completely satisfied with this solution...
45 | setTimeout(this.callback.bind(this, null, server), 50);
46 | },
47 | "then I have a the good events on the server": function(server) {
48 | // Server checks
49 | assert.ok(!server._names.server.events['hook::ready']);
50 | assert.strictEqual(server._names.server.events.eventBeforeStart, 1);
51 | assert.strictEqual(server._names.server.events.eventAfterStart, 2);
52 | assert.ok(!server._names.server.events.eventToBeDestroyed);
53 | },
54 | "and I have the good events on the client": function(server) {
55 | // Client checks
56 | assert.ok(!server._names.client.events['hook::ready']);
57 | assert.strictEqual(server._names.client.events.testEvent, 1);
58 | assert.strictEqual(server._names.client.events.eventBeforeStart, 1);
59 | assert.strictEqual(server._names.client.events.eventAfterStart, 1);
60 | assert.ok(!server._names.client.events.eventToBeDestroyed);
61 | }
62 | }
63 | }
64 | }
65 | }).export(module);
66 |
--------------------------------------------------------------------------------
/vendor/dnode-protocol/test/fn.js:
--------------------------------------------------------------------------------
1 | var assert = require('assert');
2 | var proto = require('../');
3 | var Traverse = require('traverse');
4 | var EventEmitter = require('events').EventEmitter;
5 |
6 | exports.protoFn = function () {
7 | var server = proto(function (remote, conn) {
8 | assert.ok(conn);
9 | assert.ok(conn instanceof EventEmitter);
10 |
11 | var tr = setTimeout(function () {
12 | assert.fail('never got ready event');
13 | }, 5000);
14 |
15 | conn.on('ready', function () {
16 | clearTimeout(tr);
17 | assert.eql(remote, { a : 1, b : 2 });
18 | });
19 |
20 | this.x = function (f, g) {
21 | setTimeout(f.bind({}, 7, 8, 9), 50);
22 | setTimeout(g.bind({}, [ 'q', 'r' ]), 100);
23 | };
24 | this.y = 555;
25 | });
26 |
27 | var client = proto({ a : 1, b : 2 });
28 |
29 | var s = server.create();
30 | var c = client.create();
31 |
32 | var sreqs = [];
33 | s.on('request', function (req) {
34 | sreqs.push(Traverse.clone(req));
35 | c.handle(req);
36 | });
37 |
38 | var creqs = [];
39 | c.on('request', function (req) {
40 | creqs.push(Traverse.clone(req));
41 | s.handle(req);
42 | });
43 |
44 | var tf = setTimeout(function () {
45 | assert.fail('never called f');
46 | }, 5000);
47 |
48 | var tg = setTimeout(function () {
49 | assert.fail('never called g');
50 | }, 5000);
51 |
52 | s.start();
53 |
54 | assert.eql(sreqs, [ {
55 | method : 'methods',
56 | arguments : [ { x : '[Function]', y : 555 } ],
57 | callbacks : { 0 : [ '0', 'x' ] },
58 | links : [],
59 | } ]);
60 |
61 | c.start();
62 |
63 | assert.eql(creqs, [ {
64 | method : 'methods',
65 | arguments : [ { a : 1, b : 2 } ],
66 | callbacks : {},
67 | links : [],
68 | } ]);
69 |
70 | c.request('x', [
71 | function (x, y , z) {
72 | clearTimeout(tf);
73 | assert.eql([ x, y, z ], [ 7, 8, 9 ]);
74 | },
75 | function (qr) {
76 | clearTimeout(tg);
77 | assert.eql(qr, [ 'q', 'r' ]);
78 | }
79 | ]);
80 |
81 | assert.eql(creqs.slice(1), [ {
82 | method : 'x',
83 | arguments : [ '[Function]', '[Function]' ],
84 | callbacks : { 0 : [ '0' ], 1 : [ '1' ] },
85 | links : [],
86 | } ]);
87 |
88 | var tt = setTimeout(function () {
89 | assert.fail('broken json never emitted an error');
90 | }, 5000);
91 | c.on('error', function (err) {
92 | clearTimeout(tt);
93 | assert.ok(err.stack);
94 | assert.ok(err.message.match(/^Error parsing JSON/));
95 | assert.ok(err instanceof SyntaxError);
96 | });
97 | c.parse('{');
98 | };
99 |
--------------------------------------------------------------------------------
/test/siblings/multiple-messages-test.js:
--------------------------------------------------------------------------------
1 | /*
2 | * multiple-messages-test.js: Test the ability to work with multiple hook and rather important message passing
3 | * to demonstrate some heavier network usage.
4 | *
5 | * This test suite init and start a server hook with a predefined number
6 | * of clients, emiting back and fourth the content of browser/hook.js (150kb).
7 | *
8 | * (C) 2011 Marak Squires, Charlie Robbins
9 | * MIT LICENCE
10 | *
11 | */
12 |
13 | var vows = require('vows'),
14 | assert = require('assert'),
15 | fs = require('fs'),
16 | path = require('path'),
17 | Hook = require('../../lib/hookio').Hook,
18 | macros = require('../helpers/macros'),
19 | EventEmitter = require('events').EventEmitter;
20 |
21 |
22 | //
23 | // TODO: Update fixture with a large binary file, or something
24 | //
25 | var fixture = '', i;
26 | for (i = 0; i < 5000; i++) {
27 | fixture += '#';
28 | }
29 |
30 | // create a local macro
31 | // TODO: see if it's better to put this in helpers/macros
32 | var macro = function (event, port) {
33 |
34 | var context = {
35 | topic: function (server, data) {
36 | var messager = new Hook({ name: 'simple-client-messager' });
37 |
38 | server.once('*::' + event, function (data) {
39 | server.emit('foo::response.' + event, data);
40 | });
41 |
42 | messager.once('*::response.' + event, this.callback.bind(server, null));
43 |
44 | messager.once('hook::connected', function () {
45 | messager.emit(event, {content: fixture});
46 | });
47 | messager.connect({ 'hook-port': port });
48 |
49 | }
50 | };
51 |
52 | context["the *::" + event + " should be fired correctly"] = function (data) {
53 | assert.equal(data.content, fixture);
54 | };
55 |
56 | return context;
57 | };
58 |
59 | // creates a context with a preder
60 | macro.multipleSubscriber = function (prefix, count) {
61 | var context = {},
62 | test = count;
63 |
64 | context["to listen with wildcard mapping"] = {
65 | topic: function () {
66 | var listener = new Hook({ name: 'simple-listener' }),
67 | self = this,
68 | length = count - 1;
69 |
70 | listener.on('*::test::*::*', function log () {
71 | if (--length === 0) self.callback();
72 | });
73 | listener.connect({ 'hook-port': 5052 });
74 |
75 | },
76 |
77 | "should be able to listen each of the emitted event": function () {
78 | assert.ok(true);
79 | }
80 | };
81 |
82 | while(--test) {
83 | context["to emit *::" + prefix + test] = macro(prefix + test, 5052);
84 | }
85 |
86 | return context;
87 | };
88 |
89 |
90 | // Start the batch with a with a predefined number of cycles
91 | vows.describe('hook.io/siblings/multiple-message').addBatch({
92 | "When a hook is listening on 5050": macros.assertListen('simple-server', 5052, {
93 | "and another hooks connects": macro.multipleSubscriber('test::foo::', 10)
94 | })
95 | }).export(module);
96 |
97 |
--------------------------------------------------------------------------------
/lib/hookio/config.js:
--------------------------------------------------------------------------------
1 | /*
2 | * config.js: Module responsible for config actions.
3 | *
4 | * (C) 2011 Nodejitsu Inc.
5 | * MIT LICENCE
6 | *
7 | */
8 |
9 | var nconf = require('nconf'),
10 | hookio = require('../hookio'),
11 | path = require('path'),
12 | argv = hookio.cli.argv;
13 |
14 | var config = exports.config = function (options) {
15 | var self = this;
16 |
17 | //
18 | // Each hook get's their own config.json file managed
19 | // by an instance of the `nconf.Provider`.
20 | //
21 | // Remark: This configuration path needs to load from a
22 | // default configuration file and then write to a custom
23 | // configuration file based on the hook `type/name` combo.
24 | //
25 |
26 | this.config = new nconf.Provider();
27 | function useFileStore () {
28 | if (argv.config) {
29 | self.configFilePath = path.resolve(argv.config);
30 | }
31 | self.config.use('file', { file: self.configFilePath || './config.json' });
32 | }
33 |
34 | if (options.redis) {
35 | //
36 | // Remark: try / catch is a hack for doing optional npm deps
37 | //
38 | //
39 | try {
40 | require('nconf-redis');
41 | this.config.use('redis', options.redis);
42 | } catch(ex) {
43 | console.error("(node) warning: Missing nconf-redis module");
44 | useFileStore();
45 | }
46 | } else {
47 | useFileStore();
48 | }
49 |
50 | this.config.load();
51 |
52 | //
53 | // Load the nconf store into memory
54 | //
55 | var config = this.config.store.store;
56 |
57 | function checkProperty (key, value) {
58 | if(typeof value === "function") {
59 | throw new Error('You are attempting to override prototype method: "' + key + '". This is probably a bad idea.');
60 | }
61 | }
62 |
63 | //
64 | // Iterate over nconf store and copy key values,
65 | // to Hook
66 | //
67 | Object.keys(config).forEach(function (o) {
68 | checkProperty(o, self[o]);
69 | self[o] = config[o];
70 | });
71 |
72 | //
73 | // Iterate over argv and copy key values,
74 | // to Hook ( overwriting duplicate keys from config )
75 | //
76 | Object.keys(argv).forEach(function (o) {
77 | var reserved = ["hook-port", "hook-host"];
78 | if (reserved.indexOf(o) === -1) {
79 | checkProperty(o, self[o]);
80 | self[o] = argv[o];
81 | }
82 | });
83 |
84 | //
85 | // Iterate over options and copy key values,
86 | // to Hook ( overwriting duplicate keys from argv and config )
87 | //
88 | Object.keys(options).forEach(function (o) {
89 | checkProperty(o, self[o]);
90 | self[o] = options[o];
91 | });
92 |
93 | //
94 | // Remark: This is a hack for passing arrays of objects as strings,
95 | // through argv...fix this in optimist
96 | //
97 | if (typeof this.transports === 'string') {
98 | try {
99 | this.transports = JSON.parse(this.transports);
100 | } catch (err) {
101 | console.log('warn: bad transport parse', err.message);
102 | }
103 | }
104 |
105 | }
106 |
--------------------------------------------------------------------------------
/vendor/dnode-protocol/node_modules/traverse/test/lib/deep_equal.js:
--------------------------------------------------------------------------------
1 | var traverse = require('../../');
2 |
3 | module.exports = function (a, b) {
4 | if (arguments.length !== 2) {
5 | throw new Error(
6 | 'deepEqual requires exactly two objects to compare against'
7 | );
8 | }
9 |
10 | var equal = true;
11 | var node = b;
12 |
13 | traverse(a).forEach(function (y) {
14 | var notEqual = (function () {
15 | equal = false;
16 | //this.stop();
17 | return undefined;
18 | }).bind(this);
19 |
20 | //if (node === undefined || node === null) return notEqual();
21 |
22 | if (!this.isRoot) {
23 | /*
24 | if (!Object.hasOwnProperty.call(node, this.key)) {
25 | return notEqual();
26 | }
27 | */
28 | if (typeof node !== 'object') return notEqual();
29 | node = node[this.key];
30 | }
31 |
32 | var x = node;
33 |
34 | this.post(function () {
35 | node = x;
36 | });
37 |
38 | var toS = function (o) {
39 | return Object.prototype.toString.call(o);
40 | };
41 |
42 | if (this.circular) {
43 | if (traverse(b).get(this.circular.path) !== x) notEqual();
44 | }
45 | else if (typeof x !== typeof y) {
46 | notEqual();
47 | }
48 | else if (x === null || y === null || x === undefined || y === undefined) {
49 | if (x !== y) notEqual();
50 | }
51 | else if (x.__proto__ !== y.__proto__) {
52 | notEqual();
53 | }
54 | else if (x === y) {
55 | // nop
56 | }
57 | else if (typeof x === 'function') {
58 | if (x instanceof RegExp) {
59 | // both regexps on account of the __proto__ check
60 | if (x.toString() != y.toString()) notEqual();
61 | }
62 | else if (x !== y) notEqual();
63 | }
64 | else if (typeof x === 'object') {
65 | if (toS(y) === '[object Arguments]'
66 | || toS(x) === '[object Arguments]') {
67 | if (toS(x) !== toS(y)) {
68 | notEqual();
69 | }
70 | }
71 | else if (x instanceof Date || y instanceof Date) {
72 | if (!(x instanceof Date) || !(y instanceof Date)
73 | || x.getTime() !== y.getTime()) {
74 | notEqual();
75 | }
76 | }
77 | else {
78 | var kx = Object.keys(x);
79 | var ky = Object.keys(y);
80 | if (kx.length !== ky.length) return notEqual();
81 | for (var i = 0; i < kx.length; i++) {
82 | var k = kx[i];
83 | if (!Object.hasOwnProperty.call(y, k)) {
84 | notEqual();
85 | }
86 | }
87 | }
88 | }
89 | });
90 |
91 | return equal;
92 | };
93 |
--------------------------------------------------------------------------------
/lib/hookio/query.js:
--------------------------------------------------------------------------------
1 | var hookio = require('./hook'),
2 | async = require('async'),
3 | path = require('path');
4 |
5 | exports.query = function (params, callback) {
6 |
7 | //
8 | // Performs a query on the hook to get details about other hooks.
9 | // takes an object as first parameter, which should look like:
10 | // {name:'name-of-the-targetted-hook'}
11 | // or
12 | // {type:'type-of-the-targetted-hook'}
13 | // or
14 | // {host:'hostname-hosting-some-hook-or-its-IP'}
15 | //
16 | // the result can be received either as:
17 | // - a callback(error, details) if callback is provided as a standard callback
18 | //
19 | // * error parameter will be returned if result is empty
20 | // * details will be a String (or undefined) if we have queried by name
21 | //
22 | // - a query::out({query: originalQuery, details: arrayOfDetails}) event
23 | // if callback is not defined.
24 | //
25 | // * details is then always an Array of details, and if nothing is available
26 | // for the passed query, Array is just empty.
27 | // * query contains the original query, in order for your hook to check
28 | // it's one similar to what it was looking for, or not.
29 | //
30 | // Each details provided is of the form :
31 | // {
32 | // name: 'hook-name',
33 | // type:'hook-type',
34 | // remote:{ host:'ip address', port:99999/*port number*/}
35 | // }
36 | //
37 |
38 | var self = this;
39 |
40 | params = params || {};
41 | var name = params.name,
42 | type = params.type,
43 | host = params.host;
44 |
45 | if (!self.server) {
46 | return;
47 | }
48 |
49 | if (typeof callback !== "function") {
50 | callback = function (err, details) {
51 | if (!Array.isArray(details)) {
52 | details = [details];
53 | }
54 | return self.emit("query::out", {query: params, details: details})};
55 | }
56 | if (name) {
57 | if (self._names[name]) {
58 | //console.log(callback);
59 | callback(null, self._names[name]);
60 | }
61 | else {
62 | callback(new Error("No hook named "+name+" is connected (anymore?)"));
63 | }
64 | } else if (type) {
65 | var details = Object.keys(self._names)
66 | .map(function (key) { if (self._names[key].type === type) return self._names[key]; })
67 | .filter(function (detail) {return detail});
68 |
69 | if (details.length>0) {
70 | callback(null, details);
71 | } else {
72 | callback(new Error("No hook of type "+type+" is connected (anymore?)"),[]);
73 | }
74 |
75 | } else if (host) {
76 | self.toIPs(host, function onIP(err, hosts) {
77 | var details = Object.keys(self._names).map(function getHooks(key) {
78 | if ( hosts.some( function hasHost (host) {return host === self._names[key].remote.host} ) )
79 | return self._names[key];
80 | }).filter(function (detail) {return detail});
81 |
82 | if (details.length>0)
83 | callback(null, details);
84 | else
85 | callback(new Error("No hook for host "+host+" is connected (anymore?)"),[]);
86 | });
87 | }
88 |
89 | };
--------------------------------------------------------------------------------
/test/registry/disconnection-test.js:
--------------------------------------------------------------------------------
1 | var vows = require('vows'),
2 | assert = require('assert'),
3 | Hook = require('../../lib/hookio').Hook,
4 | macros = require('../helpers/macros');
5 |
6 | // Dummy function for event subscription
7 | var emptyFn = function() {};
8 |
9 | vows.describe('hook.io/registry/complex-test').addBatch({
10 | "When a hook is listening on 5013": {
11 | topic: function() {
12 | var self = this, server = new Hook({ name: 'server', debug:true });
13 |
14 | server.once('hook::ready', self.callback.bind(server, null, server));
15 | server.on('eventBeforeStart', emptyFn);
16 |
17 | server.listen({ "hook-port": 5013 });
18 | },
19 | "and another hook connects": {
20 | topic: function(server) {
21 | server.on('eventAfterStart', emptyFn);
22 | server.on('eventAfterStart', emptyFn);
23 | server.on('eventToBeDestroyed', emptyFn);
24 |
25 | var client = new Hook({ name: 'client', debug:true }), self = this;
26 | client.once('hook::ready', function() {
27 | self.callback(null, server, client);
28 | });
29 | client.on('eventBeforeStart', emptyFn);
30 | client.on('eventToBeDestroyed', emptyFn);
31 |
32 | client.connect({ "hook-port": 5013 });
33 | },
34 | "when my hook registers an event": {
35 | topic: function(server, client) {
36 | client.on('eventAfterStart', emptyFn);
37 | server.off('eventToBeDestroyed', emptyFn);
38 | client.off('eventToBeDestroyed', emptyFn);
39 |
40 | // Register a new "testEvent"
41 | client.on('testEvent', emptyFn);
42 |
43 | // Wait a bit for the event to propagate.
44 | // I'm not completely satisfied with this solution...
45 | setTimeout(this.callback.bind(this, null, server, client), 50);
46 | },
47 | "then I disconnect and reconnect the client": {
48 | topic: function(server, client) {
49 | var self = this;
50 | client.stop(function(err) {
51 | assert.ifError(err);
52 | client.connect({ "hook-port": 5013 }, self.callback.bind(self, null, server));
53 | });
54 | },
55 | "then I have a the good events on the server": function(server) {
56 | // Server checks
57 | assert.ok(!server._names.server.events['hook::ready']);
58 | assert.strictEqual(server._names.server.events.eventBeforeStart, 1);
59 | assert.strictEqual(server._names.server.events.eventAfterStart, 2);
60 | assert.ok(!server._names.server.events.eventToBeDestroyed);
61 | },
62 | "and I have the good events on the client": function(server) {
63 | // Client checks
64 | assert.ok(!server._names.client.events['hook::ready']);
65 | assert.strictEqual(server._names.client.events.testEvent, 1);
66 | assert.strictEqual(server._names.client.events.eventBeforeStart, 1);
67 | assert.strictEqual(server._names.client.events.eventAfterStart, 1);
68 | assert.ok(!server._names.client.events.eventToBeDestroyed);
69 | }
70 | }
71 | }
72 | }
73 | }
74 | }).export(module);
75 |
--------------------------------------------------------------------------------
/vendor/EventEmitter2/test/simple/ttl.js:
--------------------------------------------------------------------------------
1 | var simpleEvents = require('nodeunit').testCase;
2 |
3 | var file = '../../lib/eventemitter2';
4 |
5 | module.exports = simpleEvents({
6 |
7 | setUp: function (callback) {
8 | var EventEmitter2;
9 |
10 | if(typeof require !== 'undefined') {
11 | EventEmitter2 = require(file).EventEmitter2;
12 | }
13 | else {
14 | EventEmitter2 = window.EventEmitter2;
15 | }
16 |
17 | this.emitter = new EventEmitter2();
18 | callback();
19 | },
20 |
21 | tearDown: function (callback) {
22 | //clean up?
23 | callback();
24 | },
25 |
26 | '1. A listener added with `once` should only listen once and then be removed.': function (test) {
27 |
28 | var emitter = this.emitter;
29 |
30 | emitter.once('test1', function () {
31 | test.ok(true, 'The event was raised once');
32 | });
33 |
34 | emitter.emit('test1');
35 | emitter.emit('test1');
36 |
37 | test.expect(1);
38 | test.done();
39 |
40 | },
41 | '2. A listener with a TTL of 4 should only listen 4 times.': function (test) {
42 |
43 | var emitter = this.emitter;
44 |
45 | emitter.many('test1', 4, function (value1) {
46 | test.ok(true, 'The event was raised 4 times.');
47 | });
48 |
49 | emitter.emit('test1', 1);
50 | emitter.emit('test1', 2);
51 | emitter.emit('test1', 3);
52 | emitter.emit('test1', 4);
53 | emitter.emit('test1', 5);
54 |
55 | test.expect(4);
56 | test.done();
57 |
58 | },
59 | '3. A listener with a TTL of 4 should only listen 4 times and pass parameters.': function (test) {
60 |
61 | var emitter = this.emitter;
62 |
63 | emitter.many('test1', 4, function (value1, value2, value3) {
64 | test.ok(typeof value1 !== 'undefined', 'got value 1');
65 | test.ok(typeof value2 !== 'undefined', 'got value 2');
66 | test.ok(typeof value3 !== 'undefined', 'got value 3');
67 | });
68 |
69 | emitter.emit('test1', 1, 'A', false);
70 | emitter.emit('test1', 2, 'A', false);
71 | emitter.emit('test1', 3, 'A', false);
72 | emitter.emit('test1', 4, 'A', false);
73 | emitter.emit('test1', 5, 'A', false);
74 |
75 | test.done();
76 |
77 | },
78 | '4. Remove an event listener by signature.': function (test) {
79 |
80 | var emitter = this.emitter;
81 | var count = 0;
82 |
83 | function f1(event) {
84 | "event A";
85 | test.ok(true, 'The event was raised less than 3 times.');
86 | }
87 |
88 | emitter.on('test1', f1);
89 |
90 | function f2(event) {
91 | "event B";
92 | test.ok(true, 'The event was raised less than 3 times.');
93 | }
94 |
95 | emitter.on('test1', f2);
96 |
97 | function f3(event) {
98 | "event C";
99 | test.ok(true, 'The event was raised less than 3 times.');
100 | }
101 |
102 | emitter.on('test1', f3);
103 |
104 | emitter.removeListener('test1', f2);
105 |
106 | emitter.emit('test1');
107 |
108 | test.expect(2);
109 | test.done();
110 |
111 | },
112 | '5. `removeListener` and `once`': function(test) {
113 |
114 | var emitter = this.emitter;
115 | var functionA = function() { test.ok(true, 'Event was fired'); };
116 |
117 | emitter.once('testA', functionA);
118 | emitter.removeListener('testA', functionA);
119 |
120 | emitter.emit('testA');
121 |
122 | test.expect(0);
123 | test.done();
124 | }
125 |
126 | });
127 |
--------------------------------------------------------------------------------
/vendor/dnode-protocol/node_modules/traverse/test/circular.js:
--------------------------------------------------------------------------------
1 | var assert = require('assert');
2 | var Traverse = require('../');
3 | var deepEqual = require('./lib/deep_equal');
4 | var util = require('util');
5 |
6 | exports.circular = function () {
7 | var obj = { x : 3 };
8 | obj.y = obj;
9 | var foundY = false;
10 | Traverse(obj).forEach(function (x) {
11 | if (this.path.join('') == 'y') {
12 | assert.equal(
13 | util.inspect(this.circular.node),
14 | util.inspect(obj)
15 | );
16 | foundY = true;
17 | }
18 | });
19 | assert.ok(foundY);
20 | };
21 |
22 | exports.deepCirc = function () {
23 | var obj = { x : [ 1, 2, 3 ], y : [ 4, 5 ] };
24 | obj.y[2] = obj;
25 |
26 | var times = 0;
27 | Traverse(obj).forEach(function (x) {
28 | if (this.circular) {
29 | assert.deepEqual(this.circular.path, []);
30 | assert.deepEqual(this.path, [ 'y', 2 ]);
31 | times ++;
32 | }
33 | });
34 |
35 | assert.deepEqual(times, 1);
36 | };
37 |
38 | exports.doubleCirc = function () {
39 | var obj = { x : [ 1, 2, 3 ], y : [ 4, 5 ] };
40 | obj.y[2] = obj;
41 | obj.x.push(obj.y);
42 |
43 | var circs = [];
44 | Traverse(obj).forEach(function (x) {
45 | if (this.circular) {
46 | circs.push({ circ : this.circular, self : this, node : x });
47 | }
48 | });
49 |
50 | assert.deepEqual(circs[0].self.path, [ 'x', 3, 2 ]);
51 | assert.deepEqual(circs[0].circ.path, []);
52 |
53 | assert.deepEqual(circs[1].self.path, [ 'y', 2 ]);
54 | assert.deepEqual(circs[1].circ.path, []);
55 |
56 | assert.deepEqual(circs.length, 2);
57 | };
58 |
59 | exports.circDubForEach = function () {
60 | var obj = { x : [ 1, 2, 3 ], y : [ 4, 5 ] };
61 | obj.y[2] = obj;
62 | obj.x.push(obj.y);
63 |
64 | Traverse(obj).forEach(function (x) {
65 | if (this.circular) this.update('...');
66 | });
67 |
68 | assert.deepEqual(obj, { x : [ 1, 2, 3, [ 4, 5, '...' ] ], y : [ 4, 5, '...' ] });
69 | };
70 |
71 | exports.circDubMap = function () {
72 | var obj = { x : [ 1, 2, 3 ], y : [ 4, 5 ] };
73 | obj.y[2] = obj;
74 | obj.x.push(obj.y);
75 |
76 | var c = Traverse(obj).map(function (x) {
77 | if (this.circular) {
78 | this.update('...');
79 | }
80 | });
81 |
82 | assert.deepEqual(c, { x : [ 1, 2, 3, [ 4, 5, '...' ] ], y : [ 4, 5, '...' ] });
83 | };
84 |
85 | exports.circClone = function () {
86 | var obj = { x : [ 1, 2, 3 ], y : [ 4, 5 ] };
87 | obj.y[2] = obj;
88 | obj.x.push(obj.y);
89 |
90 | var clone = Traverse.clone(obj);
91 | assert.ok(obj !== clone);
92 |
93 | assert.ok(clone.y[2] === clone);
94 | assert.ok(clone.y[2] !== obj);
95 | assert.ok(clone.x[3][2] === clone);
96 | assert.ok(clone.x[3][2] !== obj);
97 | assert.deepEqual(clone.x.slice(0,3), [1,2,3]);
98 | assert.deepEqual(clone.y.slice(0,2), [4,5]);
99 | };
100 |
101 | exports.circMapScrub = function () {
102 | var obj = { a : 1, b : 2 };
103 | obj.c = obj;
104 |
105 | var scrubbed = Traverse(obj).map(function (node) {
106 | if (this.circular) this.remove();
107 | });
108 | assert.deepEqual(
109 | Object.keys(scrubbed).sort(),
110 | [ 'a', 'b' ]
111 | );
112 | assert.ok(deepEqual(scrubbed, { a : 1, b : 2 }));
113 |
114 | assert.equal(obj.c, obj);
115 | };
116 |
--------------------------------------------------------------------------------
/vendor/dnode/lib/stream_socketio.js:
--------------------------------------------------------------------------------
1 | var EventEmitter = require('events').EventEmitter;
2 | var Stream = require('stream').Stream;
3 | var io = require('socket.io');
4 | var fs = require('fs');
5 |
6 | var bundle = (function () {
7 | var cache = null;
8 | var file = __dirname + '/../browser/bundle.js';
9 |
10 | return function (req, res) {
11 | if (cache) {
12 | res.setHeader('content-type', 'text/javascript');
13 | res.setHeader('last-modified', cache.modified.toGMTString());
14 | res.setHeader('date', new Date().toGMTString());
15 |
16 | var ims = req.headers['if-modified-since'];
17 | if (ims) {
18 | var m = new Date(ims);
19 | if (m >= cache.modified) {
20 | res.statusCode = 304;
21 | res.end();
22 | return;
23 | }
24 | }
25 |
26 | res.statusCode = 200;
27 | res.end(cache.source);
28 | }
29 | else fs.stat(file, function (err0, stat) {
30 | fs.readFile(file, function (err1, src) {
31 | if (err0 || err1) {
32 | var e = err0 || err1;
33 | console.error(e.message || e);
34 | res.statusCode = 500;
35 | res.setHeader('content-type', 'text/plain');
36 | res.end('an error occured loading the bundle');
37 | }
38 | else {
39 | cache = {
40 | source : src,
41 | modified : stat.mtime,
42 | };
43 | bundle(req, res);
44 | }
45 | });
46 | });
47 | };
48 | })();
49 |
50 | module.exports = function (webserver, mount, ioOptions) {
51 | if (ioOptions['log level'] === undefined) {
52 | ioOptions['log level'] = -1;
53 | }
54 |
55 | var sock = io.listen(webserver, ioOptions);
56 | var server = new EventEmitter;
57 |
58 | if (mount && webserver.use) {
59 | webserver.use(function (req, res, next) {
60 | if (req.url.split('?')[0] === mount) {
61 | bundle(req, res);
62 | }
63 | else next()
64 | });
65 | }
66 | else if (mount) {
67 | if (!webserver._events) webserver._events = {};
68 | var ev = webserver._events;
69 |
70 | if (!ev.request) ev.request = [];
71 | if (!Array.isArray(ev.request)) ev.request = [ ev.request ];
72 |
73 | ev.request.push(function (req, res) {
74 | if (!res.finished && req.url.split('?')[0] === mount) {
75 | bundle(req, res);
76 | }
77 | });
78 | }
79 |
80 | sock.sockets.on('connection', function (client) {
81 | var stream = new Stream;
82 |
83 | stream.socketio = client;
84 | stream.readable = true;
85 | stream.writable = true;
86 |
87 | stream.write = client.send.bind(client);
88 | stream.end = stream.destroy
89 | = client.disconnect.bind(client.disconnect);
90 |
91 | client.on('message', stream.emit.bind(stream, 'data'));
92 | client.on('error', stream.emit.bind(stream, 'error'));
93 |
94 | client.on('disconnect', function () {
95 | stream.writable = false;
96 | stream.readable = false;
97 | stream.emit('end');
98 | });
99 |
100 | server.emit('connection', stream);
101 | });
102 |
103 | return server;
104 | };
105 |
--------------------------------------------------------------------------------
/vendor/dnode-protocol/test/scrub.js:
--------------------------------------------------------------------------------
1 | var assert = require('assert');
2 | var Scrubber = require('../').Scrubber;
3 |
4 | exports.noFuncs = function () {
5 | var s = new Scrubber;
6 | assert.eql(
7 | s.scrub([ 1, 2, 3 ]),
8 | {
9 | arguments : [ 1, 2, 3 ],
10 | callbacks : [],
11 | links : [],
12 | }
13 | );
14 |
15 | assert.eql(
16 | s.scrub([ 4, { a : 5, b : 6 } ]),
17 | {
18 | arguments : [ 4, { a : 5, b : 6 } ],
19 | callbacks : [],
20 | links : [],
21 | }
22 | );
23 | };
24 |
25 | exports.funcs = function () {
26 | var s = new Scrubber;
27 |
28 | var calls = { f : 0, g : 0 };
29 | var f = function () { calls.f ++ };
30 | var g = function () { calls.g ++ };
31 |
32 | var sc = s.scrub([ 1, 2, f, g ]);
33 | assert.eql(sc, {
34 | arguments : [ 1, 2, '[Function]', '[Function]' ],
35 | callbacks : { 0 : [ '2' ], 1 : [ '3' ] },
36 | links : [],
37 | });
38 |
39 | s.callbacks[0]();
40 | assert.eql(calls, { f : 1, g : 0 });
41 |
42 | s.callbacks[1]();
43 | assert.eql(calls, { f : 1, g : 1 });
44 | };
45 |
46 | exports.link = function () {
47 | var s = new Scrubber;
48 | var x = [ [ 0, { a : 1, b : 2, c : 3 }, 4 ], 5, 6 ];
49 | x[0][1].d = x[0][1];
50 | var sc = s.scrub(x);
51 |
52 | assert.eql(sc, {
53 | arguments : [
54 | [ 0, { a : 1, b : 2, c : 3, d : '[Circular]' }, 4 ], 5, 6
55 | ],
56 | callbacks : {},
57 | links : [ { from : [ '0', '1' ], to : [ '0', '1', 'd' ] } ],
58 | });
59 | };
60 |
61 | exports.multilink = function () {
62 | var s = new Scrubber;
63 | var x = [ [ 0, { a : 1, b : 2, c : 3 }, 4 ], 5, 6 ];
64 | x[0][1].d = x[0][1];
65 | x.push(x);
66 | var sc = s.scrub(x);
67 |
68 | assert.eql(sc, {
69 | arguments : [
70 | [ 0, { a : 1, b : 2, c : 3, d : '[Circular]' }, 4 ],
71 | 5, 6, '[Circular]'
72 | ],
73 | callbacks : {},
74 | links : [
75 | { from : [ '0', '1' ], to : [ '0', '1', 'd' ] },
76 | { from : [], to : [ '3' ] },
77 | ],
78 | });
79 | };
80 |
81 | exports.enumSetLink = function () {
82 | var s = new Scrubber;
83 | var req = {
84 | method : 0,
85 | arguments : [ 33, '[Function]' ],
86 | callbacks : { 0 : [ '1' ] },
87 | links : [ {
88 | from : [ '0' ],
89 | to : [ '1', 'constructor', 'prototype', 'beep' ]
90 | } ]
91 | };
92 |
93 | var args = s.unscrub(req, function (id) {
94 | return function () {};
95 | });
96 | assert.ok(!(function () {}).beep, 'created non-enumerable property');
97 | };
98 |
99 | exports.enumGetLink = function () {
100 | var s = new Scrubber;
101 | var req = {
102 | method : 0,
103 | arguments : [ 'doom', '[Function]' ],
104 | callbacks : { 0 : [ '1' ] },
105 | links : [ {
106 | from : [ '1', 'constructor', 'prototype', 'toString' ],
107 | to : [ '0' ]
108 | } ]
109 | };
110 |
111 | var args = s.unscrub(req, function (id) {
112 | return function () {};
113 | });
114 |
115 | assert.ok(args[0] === undefined);
116 | };
117 |
118 | exports.skipSet = function () {
119 | var s = new Scrubber;
120 | var req = {
121 | method : 0,
122 | arguments : [ { x : 33 }, '[Function]' ],
123 | callbacks : { 0 : [ '1' ] },
124 | links : [ { from : [ '0', 'x' ], to : [ '2' ] } ]
125 | };
126 |
127 | var args = s.unscrub(req, function (id) {
128 | return function () {};
129 | });
130 | assert.equal(args[2], 33);
131 | };
132 |
--------------------------------------------------------------------------------