├── examples
    ├── coffee
    │   ├── server.coffee
    │   ├── config.coffee
    │   └── queue.coffee
    ├── basic
    │   ├── app.js
    │   ├── talker.js
    │   └── listener.js
    ├── hello
    │   ├── app.js
    │   ├── greeter.js
    │   └── talker.js
    └── common
    │   └── child.js
├── .gitignore
├── lib
    ├── lib.js
    ├── errors.js
    ├── eventer.js
    ├── logger.js
    ├── QueueLogger.js
    ├── options.js
    ├── QueueMonitor.js
    ├── MongoMQ.js
    └── MongoConnection.js
├── .project
├── .gitattributes
├── package.json
├── license.txt
├── bin
    └── MongoMQ.js
└── readme.md


/examples/coffee/server.coffee:
--------------------------------------------------------------------------------
1 | require './queue'


--------------------------------------------------------------------------------
/examples/coffee/config.coffee:
--------------------------------------------------------------------------------
1 | exports.db =
2 |   	host: 	'localhost'
3 |   	name: 	'tests'
4 | 
5 | exports.db.url = "mongodb://#{exports.db.host}/#{exports.db.name}"


--------------------------------------------------------------------------------
/examples/basic/app.js:
--------------------------------------------------------------------------------
1 | var Children = require('../common/child');
2 | var talker = Children.startChild('./talker');
3 | var listener = Children.startChild('./listener');
4 | 


--------------------------------------------------------------------------------
/examples/hello/app.js:
--------------------------------------------------------------------------------
1 | var Children = require('../common/child');
2 | var talker = Children.startChild('./talker');
3 | var listener = Children.startChild('./greeter');
4 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | #################
 2 | ## npm/Node.js
 3 | #################
 4 | 
 5 | node_modules
 6 | 
 7 | ############
 8 | ## Windows
 9 | ############
10 | 
11 | # Windows image file caches
12 | Thumbs.db
13 | 
14 | # Folder config file
15 | Desktop.ini
16 | 
17 | #Editor metadata
18 | .idea


--------------------------------------------------------------------------------
/lib/lib.js:
--------------------------------------------------------------------------------
1 | exports.MongoMQ = require('./MongoMQ');
2 | exports.Eventer = require('./eventer');
3 | exports.Logger = require('./logger');
4 | exports.MongoConnection = require('./MongoConnection');
5 | exports.options = require('./options');
6 | exports.QueueMonitor = require('./QueueMonitor');
7 | 


--------------------------------------------------------------------------------
/.project:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <projectDescription>
 3 | 	<name>MongoMQ</name>
 4 | 	<comment></comment>
 5 | 	<projects>
 6 | 	</projects>
 7 | 	<buildSpec>
 8 | 	</buildSpec>
 9 | 	<natures>
10 | 		<nature>com.aptana.projects.webnature</nature>
11 | 	</natures>
12 | </projectDescription>
13 | 


--------------------------------------------------------------------------------
/examples/coffee/queue.coffee:
--------------------------------------------------------------------------------
 1 | config  = require './config'
 2 | MongoMQ = (require '../../lib/lib').MongoMQ
 3 | 
 4 | queue = new MongoMQ
 5 | 	autoStart: 	true
 6 | 	host:		config.db.host
 7 | 	collectionName:	'capped_collection'
 8 | 	database:	config.db.name
 9 | 
10 | #queue.start()
11 | 
12 | exports.queue = queue


--------------------------------------------------------------------------------
/lib/errors.js:
--------------------------------------------------------------------------------
1 | var errors = module.exports = {
2 |       E_CONNCLOSED: 'No active server connection!',
3 |       E_NODB: 'No database name provided!',
4 |       E_INVALIDFILTER: 'Invalid or no filter provided!',
5 |       E_NOCALLBACK: 'No callback provided, callback is required!',
6 |       E_INVALIDINDEX: 'Invalid or no index provided!',
7 |       E_INVALIDCURSORCOLLECTION: 'Supplied collection is not capped, tailed cursors only work on capped collections!'
8 |     };


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
 1 | # Auto detect text files and perform LF normalization
 2 | * text=auto
 3 | 
 4 | # Custom for Visual Studio
 5 | *.cs     diff=csharp
 6 | *.sln    merge=union
 7 | *.csproj merge=union
 8 | *.vbproj merge=union
 9 | *.fsproj merge=union
10 | *.dbproj merge=union
11 | 
12 | # Standard to msysgit
13 | *.doc	 diff=astextplain
14 | *.DOC	 diff=astextplain
15 | *.docx diff=astextplain
16 | *.DOCX diff=astextplain
17 | *.dot  diff=astextplain
18 | *.DOT  diff=astextplain
19 | *.pdf  diff=astextplain
20 | *.PDF	 diff=astextplain
21 | *.rtf	 diff=astextplain
22 | *.RTF	 diff=astextplain
23 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "author": {
 3 |     "name": "Jeremy Darling",
 4 |     "email": "jeremy.darling@gmail.com"
 5 |   },
 6 |   "name": "mongomq",
 7 |   "version": "0.3.9",
 8 |   "repository": {
 9 |     "type": "git",
10 |     "url": "git://github.com/jdarling/MongoMQ.git"
11 |   },
12 |   "main": "./lib/lib",
13 |   "license": "MIT",
14 |   "contributors": [
15 |     {
16 |       "name": "mfrobben"
17 |     },
18 |     {
19 |       "name": "joscha"
20 |     },
21 |     {
22 |       "name": "nickpalmer"
23 |     }
24 |   ],
25 |   "engines": {
26 |     "node": ">= v0.8.2"
27 |   },
28 |   "dependencies": {
29 |     "mongodb": "^2.2.16",
30 |     "node-uuid": "^1.4.7"
31 |   }
32 | }
33 | 


--------------------------------------------------------------------------------
/examples/basic/talker.js:
--------------------------------------------------------------------------------
 1 | var MC = require('../../lib/lib').MongoConnection;
 2 | var MQ = require('../../lib/lib').MongoMQ;
 3 | 
 4 | var options = {databaseName: 'tests', queueCollection: 'capped_collection', autoStart: false};
 5 | //var options = {servers: ['ndcsrvcdep601', 'ndcsrvcdep602'], databaseName: 'tests', queueCollection: 'capped_collection', autoStart: false};
 6 | 
 7 | var mq = module.exports = new MQ(options);
 8 | 
 9 | var recordNumber = 0;
10 | var putRecord = function(){
11 |   console.log('Emitting: '+recordNumber);
12 |   mq.emit('test', recordNumber);
13 |   recordNumber++;
14 |   setTimeout(putRecord, 5);
15 | };
16 | 
17 | (function(){
18 |   var logger = new MC(options);
19 |   logger.open(function(err, mc){
20 |     if(err){
21 |       console.log('ERROR: ', err);
22 |     }else{
23 |       mc.collection('log', function(err, loggingCollection){
24 |         loggingCollection.remove({},  function(){
25 |           mq.start(function(err){
26 |             putRecord();
27 |           });
28 |         });
29 |       });
30 |     }
31 |   });
32 | })();
33 | 


--------------------------------------------------------------------------------
/license.txt:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) <year> <copyright holders>
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/examples/hello/greeter.js:
--------------------------------------------------------------------------------
 1 | var MC = require('../../lib/lib').MongoConnection;
 2 | var MQ = require('../../lib/lib').MongoMQ;
 3 | 
 4 | var options = {host: 'localhost', databaseName: 'tests', queueCollection: 'capped_collection', autoStart: true,
 5 |     serverOptions: {
 6 |       socketOptions: {
 7 |         connectTimeoutMS: 15000,
 8 |         socketTimeoutMS: 15000
 9 |       }
10 |     }
11 | };
12 | 
13 | var mq = module.exports = new MQ(options);
14 | 
15 | var log;
16 | 
17 | var handleRecord = function(err, data, next){
18 |   if(!err){
19 |     log.insert({handled: data}, {w:0});
20 |     next('Hello '+(data||'world')+'!');
21 |   }else{
22 |     console.log('err: ', err);
23 |     next();
24 |   }
25 | };
26 | 
27 | mq.on('greet', handleRecord);
28 | 
29 | (function(){
30 |   var logger = new MC(options);
31 |   logger.open(function(err, mc){
32 |     if(err){
33 |       console.log('ERROR: ', err);
34 |     }else{
35 |       mc.collection('log', function(err, loggingCollection){
36 |         log = loggingCollection;
37 |         if(!options.autoStart){
38 |           mq.start(function(err){
39 |             if(err){
40 |               console.log(err);
41 |             }
42 |           });
43 |         }
44 |       });
45 |     }
46 |   });
47 | })();
48 | 


--------------------------------------------------------------------------------
/examples/hello/talker.js:
--------------------------------------------------------------------------------
 1 | var MC = require('../../lib/lib').MongoConnection;
 2 | var MQ = require('../../lib/lib').MongoMQ;
 3 | 
 4 | var options = {host: 'localhost', databaseName: 'tests', queueCollection: 'capped_collection', autoStart: true};
 5 | 
 6 | var mq = module.exports = new MQ(options);
 7 | 
 8 | var recordNumber = 0;
 9 | var emitRecord = function(){
10 |   console.log('emitting '+recordNumber);
11 |   mq.emit('greet', recordNumber, function(err, data){
12 |     console.log('Response:');
13 |     console.log(' err>', err);
14 |     console.log(' dat>', data);
15 |     emitRecord();
16 |   });
17 |   recordNumber++;
18 | };
19 | 
20 | mq.ready(function(){
21 |   console.log('ready');
22 | });
23 | 
24 | var putRecord = function(){
25 |   setTimeout(function(){
26 |     emitRecord();
27 |     putRecord();
28 |   }, 100);
29 | };
30 | 
31 | (function(){
32 |   var logger = new MC(options);
33 |   logger.open(function(err, mc){
34 |     if(err){
35 |       console.log('ERROR: ', err);
36 |     }else{
37 |       mc.collection('log', function(err, loggingCollection){
38 |         loggingCollection.remove({},  function(){
39 |           if(!options.autoStart){
40 |             /*
41 |             mq.start(function(err){
42 |               putRecord();
43 |             });
44 |             */
45 |           }
46 |         });
47 |       });
48 |     }
49 |   });
50 | })();
51 | 
52 | emitRecord();
53 | 


--------------------------------------------------------------------------------
/examples/common/child.js:
--------------------------------------------------------------------------------
 1 | var spawn = require('child_process').spawn;
 2 | 
 3 | var _children = [];
 4 | 
 5 | var Children = function(){
 6 | };
 7 | 
 8 | Children.prototype.startChild = function(fileName){
 9 |   var args = Array.prototype.slice.call(arguments);
10 |   var child = spawn('node', args);
11 |   child.processFile = fileName;
12 |   child.arguments = args;
13 |   child.on('exit', (function(aChild){
14 |     return function(code, signal){
15 |       var idx = _children.indexOf(aChild);
16 |       if(idx>-1&&_children[idx]) console.log(('Child ('+_children[idx].processFile+') '+aChild.pid+' is dying!').yellow);
17 |       else console.log(('Child ('+aChild.pid+') is dying!').yellow);
18 |       if(idx>-1){
19 |         _children.splice(idx, 1);
20 |         console.log('Child killed successfully!'.green);
21 |       }
22 |     };
23 |   })(child));
24 |   child.on('uncaughtException', (function(aChild){
25 |     return function(err){
26 |       console.error('EXCEPTION: ', err);
27 |     };
28 |   })(child));
29 |   child.stdout.on('data', (function(aChild){
30 |     return function(data){
31 |       console.log(data.toString());
32 |     };
33 |   })(child));
34 |   child.stderr.on('data', (function(aChild){
35 |     return function(data){
36 |       console.error('ERROR: ', data.toString());
37 |     };
38 |   })(child));
39 |   _children.push(child);
40 |   return child;
41 | };
42 | 
43 | Children.prototype.children = function(){
44 |   return _children;
45 | };
46 | 
47 | module.exports = new Children();
48 | 


--------------------------------------------------------------------------------
/examples/basic/listener.js:
--------------------------------------------------------------------------------
 1 | var MC = require('../../lib/lib').MongoConnection;
 2 | var MQ = require('../../lib/lib').MongoMQ;
 3 | 
 4 | var options = {databaseName: 'tests', queueCollection: 'capped_collection', autoStart: false};
 5 | //var options = {servers: ['ndcsrvcdep601', 'ndcsrvcdep602'], databaseName: 'tests', queueCollection: 'capped_collection', autoStart: false};
 6 | 
 7 | //options.listenerType = 'streams';
 8 | //options.listenerType = 'nextObject';
 9 | 
10 | //Streams are great for broadcast event listeners, they are BAD for things that require processing and response
11 | // as they can allow for node saturation and they are greedy.  The default listenerType is 'nextObject', you
12 | // can also set the listener type on the listener itself using:
13 | //   MQ.on('event', {listenerType: ''}, callback) or
14 | //   MQ.once('event', {listenerType: ''}, callback)
15 | 
16 | var mq = module.exports = new MQ(options);
17 | 
18 | var log;
19 | 
20 | var handleRecord = function(err, data, next){
21 |   var w = Math.floor(Math.random()*100);
22 |   if(!err){
23 |     console.log('data: ', data, 'wait: ', w);
24 |     log.insert({handled: data}, {w:0});
25 |   }else{
26 |     console.log('err: ', err, 'wait: ', w);
27 |   }
28 |   next();
29 | };
30 | 
31 | mq.on('test', handleRecord);
32 | 
33 | (function(){
34 |   var logger = new MC(options);
35 |   logger.open(function(err, mc){
36 |     if(err){
37 |       console.log('ERROR: ', err);
38 |     }else{
39 |       mc.collection('log', function(err, loggingCollection){
40 |         log = loggingCollection;
41 |         mq.start(function(err){
42 |           if(err){
43 |             console.log(err);
44 |           }
45 |         });
46 |       });
47 |     }
48 |   });
49 | })();
50 | 


--------------------------------------------------------------------------------
/lib/eventer.js:
--------------------------------------------------------------------------------
 1 | var util = require('util');
 2 | var EventEmitter = require('events').EventEmitter;
 3 | 
 4 | var defaultError = function () {};
 5 | 
 6 | var Eventer = module.exports = function(hosting){
 7 |   var self = this;
 8 |   self.hosting = hosting;
 9 |   self.on('error', defaultError);
10 | };
11 | 
12 | util.inherits(Eventer, EventEmitter);
13 | 
14 | Eventer.description = 'A wrapper around EventEmitter to provide some high level functionality and eased useage pattern within MongoMQ.';
15 | 
16 | Eventer.prototype.call = function(eventName, err, response){
17 |   var self = this;
18 |   self.emit(eventName, err, response||self.hosting);
19 | };
20 | Eventer.prototype.call.description = 'Calls an event.';
21 | 
22 | Eventer.prototype.registerTo = function(what){
23 |   var self = this, keys = Object.keys(self), i, l=keys.length, key, value;
24 |   for(i=0; i<l; i++){
25 |     key = keys[i];
26 |     value = self[key];
27 |     if(typeof(value)==='function'){
28 |       what[key]=(function(f){
29 |         return function(){
30 |           f.apply(self, arguments);
31 |         }
32 |       })(value);
33 |     }
34 |   }
35 | };
36 | Eventer.prototype.call.description = 'Adds the Eventer methods to the provided object through closures so they can be used directly.';
37 | 
38 | Eventer.prototype.checkNoError = function(err, callback, noThrow){
39 |   var self = this, handlers = self.listeners('error'), handlerCount = handlers.length, hasCallback = typeof(callback)==='function';
40 |   if(!err){
41 |     return true;
42 |   }
43 |   if(!(err instanceof Error)){
44 |     err = new Error(err);
45 |   }
46 |   if(handlerCount>0){
47 |     self.emit('error', err, self.hosting);
48 |   }
49 |   if(hasCallback){
50 |     callback(err);
51 |   }
52 |   if((handlerCount===0)&&(!noThrow)&&(!hasCallback)){
53 |     throw err.toString();
54 |   }
55 |   return false;
56 | };
57 | Eventer.prototype.checkNoError.description = 'Checks to see if there is an error, and if their is handles it appropriatly.';
58 | 
59 | Eventer.prototype.surface = function(what){
60 |   what = what instanceof Array?what:[what];
61 |   var self = this, i,  l = what.length, event;
62 |   for(i=0; i<l; i++){
63 |     event = what[i];
64 |     self.hosting[event] = (function(eventName){
65 |       return function(callback){
66 |         self.on(eventName, callback);
67 |       };
68 |     })(event);
69 |   }
70 | };
71 | Eventer.prototype.surface.description = 'Used to surface a specific set of event wrappers to the hosted object.';
72 | 


--------------------------------------------------------------------------------
/lib/logger.js:
--------------------------------------------------------------------------------
 1 | var fs = require('fs');
 2 | var util = require('util');
 3 | var Options = require('./options');
 4 | 
 5 | var defaults = {
 6 |   autoInit: true
 7 | };
 8 | 
 9 | var Logger = module.exports = function(options, callInit){
10 |   var self = this;
11 |   options = Options.ensure(options||{}, defaults);
12 |   if(options.autoInit){
13 |     self.init(options);
14 |   }
15 | };
16 | 
17 | Logger.prototype.debug = function(message, object){
18 |   this.logItem('debug', message, object);
19 | };
20 | Logger.prototype.debug.description = 'Writes a debug message to the log.';
21 | 
22 | Logger.prototype.log = function(message, object){
23 |   this.logItem('log', message, object);
24 | };
25 | Logger.prototype.log.description = 'Writes a log message to the log.';
26 | 
27 | Logger.prototype.error = function(message, object){
28 |   this.logItem('ERROR', message, object);
29 | };
30 | Logger.prototype.error.description = 'Writes a error message to the log.';
31 | 
32 | Logger.prototype.init = function(options){
33 |   var self = this;
34 |   options=options||{};
35 |   self.fileStream = options.toFile!==false?fs.createWriteStream(fs.existsSync(process.argv[1])?process.argv[1]+'.log':'log.txt')||false:false;
36 |   self.toScreen = !!options.toScreen;
37 |   self.log('started', process);
38 |   self.divider();
39 | };
40 | Logger.prototype.init.description = 'Initializes the logging object, this is the other routine to replace if you want to write your own logger.';
41 | 
42 | Logger.prototype.logItem = function(level, message, object){
43 |   this.write((level||'').toLowerCase()==='error', level+':', message+(object?'\r\n'+util.inspect(object, false, null, false, false):''));
44 | };
45 | Logger.prototype.logItem.description = 'Writes a specific type of message to the log.';
46 | 
47 | Logger.prototype.write = function(force){
48 |   var self = this;
49 |   var startAt = 1, args = Array.prototype.slice.apply(arguments), i, l = args.length, msg = '';
50 |   if(typeof(force)!=='boolean'){
51 |     startAt--;
52 |     force = false;
53 |   }
54 |   for(i=startAt; i<l; i++){
55 |     if(typeof(args[i])!=='string'){
56 |       msg += util.inspect(args[i], false, null, false, false);
57 |     }else{
58 |       msg += args[i];
59 |     }
60 |     msg+='\t';
61 |   }
62 |   if(force){
63 |     console.log(msg);
64 |   }
65 |   if(self.fileStream){
66 |     self.fileStream.write((new Date())+'\r\n'+msg+'\r\n');
67 |   }
68 |   if((!force)&&(self.toScreen)){
69 |     console.log(msg);
70 |   }
71 | };
72 | Logger.prototype.write.description = 'Performs the actual write, if your going to derrive from Logger this is the routine to replace.';
73 | 
74 | Logger.prototype.divider = function(){
75 |   var self = this;
76 |   if(self.toFile){
77 |     self.toFile.write((new Array(40).join('-='))+'\r\n');
78 |   }
79 | };
80 | Logger.prototype.divider.description = 'Writes a divider to the log.';
81 | 


--------------------------------------------------------------------------------
/lib/QueueLogger.js:
--------------------------------------------------------------------------------
  1 | var MongoConnection = require('./MongoConnection');
  2 | var MongoMQ = require('./MongoMQ');
  3 | var Logger = require('logger');
  4 | var util = require('util');
  5 | var Options = require('options');
  6 | var hostName = require('os').hostname();
  7 | var appName = process.argv[1];
  8 | 
  9 | var defaults = {
 10 |   loggingCollection: 'mongomq_log',
 11 | };
 12 | 
 13 | var QueueLogger = module.exports = function(bindTo, options){
 14 |   var self = this;
 15 |   self.options = Options.ensure(options||{}, defaults);
 16 |   self.bindTo = bindTo;
 17 |   Logger.call(self, self.options);
 18 | };
 19 | 
 20 | QueueLogger.prototype.init = function(){
 21 |   options = Options.ensure(self.options, self.bindTo.options);
 22 |   if(options.logger){
 23 |     options.logger = false;
 24 |   }
 25 |   new MongoConnection(options, function(err, db){
 26 |     if(err){
 27 |       throw err;
 28 |     }else{
 29 |       self.db = db;
 30 |       self.bindTo.eventer.on('recieved', function(){
 31 |         self.messageRecieved.apply(self, arguments);
 32 |       });
 33 |       self.bindTo.eventer.on('sent', function(){
 34 |         self.messageSent.apply(self, arguments);
 35 |       });
 36 |     }
 37 |   });
 38 | };
 39 | 
 40 | QueueLogger.prototype.stop = function(){
 41 |   if(self.db){
 42 |     self.db.close();
 43 |     self.db = false;
 44 |   }
 45 | };
 46 | 
 47 | Logger.prototype.write = function(force){
 48 |   var self = this;
 49 |   var startAt = 1, args = Array.prototype.slice.apply(arguments), i, l = args.length, msg = '';
 50 |   if(typeof(force)!=='boolean'){
 51 |     startAt--;
 52 |     force = false;
 53 |   }
 54 |   args = args.splice(startAt, args.length);
 55 |   if(self.db){
 56 |     self.db.collection(self.options.loggingCollection, function(err, collection){
 57 |       if(collection){
 58 |         collection.insert({
 59 |           message: args
 60 |         }, {w: 0});
 61 |       }
 62 |     });
 63 |   }
 64 | };
 65 | 
 66 | QueueLogger.prototype.messageRecieved = function(msg){
 67 |   if(self.db){
 68 |     self.db.collection(self.options.loggingCollection, function(err, collection){
 69 |       if(collection){
 70 |         collection.insert({
 71 |           got: msg.event,
 72 |           host: hostName,
 73 |           app: appName,
 74 |           from: msg.host,
 75 |           msg_id: msg._id,
 76 |           message: msg
 77 |         }, {w: 0});
 78 |       }
 79 |     });
 80 |   }
 81 | };
 82 | QueueLogger.prototype.messageRecieved.description = 'Used to record when a message gets recieved.';
 83 | 
 84 | QueueLogger.prototype.messageSent = function(msg){
 85 |   if(self.db){
 86 |     self.db.collection(self.options.loggingCollection, function(err, collection){
 87 |       if(collection){
 88 |         collection.insert({
 89 |           sending: msg.event,
 90 |           host: hostName,
 91 |           app: appName,
 92 |           msg_id: msg._id,
 93 |           message: msg
 94 |         }, {w: 0});
 95 |       }
 96 |     });
 97 |   }
 98 | };
 99 | QueueLogger.prototype.messageSent.description = 'Used to record when a message gets sent.';
100 | 


--------------------------------------------------------------------------------
/lib/options.js:
--------------------------------------------------------------------------------
 1 | 
 2 | var Options = module.exports;
 3 | 
 4 | var extend = function(){
 5 |   // copy reference to target object
 6 |   var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options, name, src, copy;
 7 | 
 8 |   // Handle a deep copy situation
 9 |   if (typeof target === 'boolean') {
10 |     deep = target;
11 |     target = arguments[1] || {};
12 |     // skip the boolean and the target
13 |     i = 2;
14 |   }
15 | 
16 |   // Handle case when target is a string or something (possible in deep copy)
17 |   if (typeof target !== 'object' && !typeof target === 'function')
18 |     target = {};
19 | 
20 |   var isPlainObject = function(obj) {
21 |     // Must be an Object.
22 |     // Because of IE, we also have to check the presence of the constructor property.
23 |     // Make sure that DOM nodes and window objects don't pass through, as well
24 |     if (!obj || toString.call(obj) !== '[object Object]' || obj.nodeType || obj.setInterval)
25 |       return false;
26 |     
27 |     var has_own_constructor = hasOwnProperty.call(obj, 'constructor');
28 |     var has_is_property_of_method = hasOwnProperty.call(obj.constructor.prototype, 'isPrototypeOf');
29 |     // Not own constructor property must be Object
30 |     if (obj.constructor && !has_own_constructor && !has_is_property_of_method)
31 |       return false;
32 |     
33 |     // Own properties are enumerated firstly, so to speed up,
34 |     // if last one is own, then all properties are own.
35 | 
36 |     var last_key;
37 |     for (key in obj)
38 |       last_key = key;
39 |     
40 |     return typeof last_key === 'undefined' || hasOwnProperty.call(obj, last_key);
41 |   };
42 | 
43 |   for (; i < length; i++) {
44 |     // Only deal with non-null/undefined values
45 |     if ((options = arguments[i]) !== null) {
46 |       if(options instanceof Array){
47 |         if(!deep) target = options.concat();
48 |         else{
49 |           var j, l = options.length;
50 |           target = [];
51 |           for(j = 0; j < l; j++){
52 |             target.push(extend(deep, options[j]));
53 |           }
54 |         }
55 |       }else{// Extend the base object
56 |         for (name in options) {
57 |           src = target[name];
58 |           copy = options[name];
59 | 
60 |           // Prevent never-ending loop
61 |           if (target === copy)
62 |               continue;
63 | 
64 |           // Recurse if we're merging object literal values or arrays
65 |           if (deep && copy && (isPlainObject(copy) || Array.isArray(copy))) {
66 |             var clone = src && (isPlainObject(src) || Array.isArray(src)) ? src : Array.isArray(copy) ? [] : {};
67 | 
68 |             // Never move original objects, clone them
69 |             target[name] = extend(deep, clone, copy);
70 |           // Don't bring in undefined values
71 |           } else if ((typeof copy !== 'undefined')&&(typeof(target[name])==='undefined')){
72 |             target[name] = copy;
73 |           }
74 |         }
75 |       }
76 |     }
77 |   }
78 | 
79 |   // Return the modified object
80 |   return target;
81 | };
82 | 
83 | Options.ensure = function(base, defaults){
84 |   return defaults?extend(true, base||{}, defaults):base||{};
85 | };
86 | Options.ensure.description = 'Used to ensure that a set of defaults exist on an options object.';
87 | 


--------------------------------------------------------------------------------
/bin/MongoMQ.js:
--------------------------------------------------------------------------------
  1 | var MongoMQ = require('../lib/MongoMQ');
  2 | var repl = require('repl');
  3 | 
  4 | var l = process.argv.length, tmp, names, reCmdLineStrip=/^(\-|\\|\/)*/i, opts = {autoStart: false},
  5 |   alias = {
  6 |     db: 'databaseName',
  7 |     collection: 'queueCollection',
  8 |     queue: 'queueCollection'
  9 |   };
 10 | for(var i = 2; i < l; i++){
 11 |   tmp = process.argv[i].replace(reCmdLineStrip, '').split('=');
 12 |   name = tmp.shift();
 13 |   if(tmp.length>0) val = tmp.join('=');
 14 |   else val = true;
 15 |   tmp = opts;
 16 |   names = name.split('.');
 17 |   while(names.length>1){
 18 |     name = names.shift();
 19 |     name = alias[name]||name;
 20 |     tmp = tmp[name]=tmp[name]||{};
 21 |   }
 22 |   name = names.shift();
 23 |   name = alias[name]||name;
 24 |   tmp[name]=val;
 25 | }
 26 | 
 27 | var queue = new MongoMQ(opts);
 28 | 
 29 | queue.ready(function(){
 30 |   console.log('Connected');
 31 | });
 32 | 
 33 | queue.stopped(function(){
 34 |   console.log('Disconnected');
 35 | });
 36 | 
 37 | queue.error(function(err){
 38 |   console.log(err);
 39 | });
 40 | 
 41 | var r = repl.start({
 42 |       prompt: "MongoMQ>"
 43 |     });
 44 | 
 45 | r.on('exit', function(){
 46 |   queue.stop(); // force a close
 47 | });
 48 | 
 49 | var funcName, value, funcs = [], ftmp;
 50 | for(funcName in queue){
 51 |   value = queue[funcName];
 52 |   if(typeof(value)=='function'){
 53 |     ftmp = r.context[funcName]||(function(f){
 54 |         return function(){
 55 |           f.apply(queue, arguments);
 56 |         };
 57 |       })(value);
 58 |     funcs.push({name: funcName, description: value.description, f: ftmp, a: value});
 59 |     if(!r.context[funcName]){
 60 |       r.context[funcName] = ftmp;
 61 |     }
 62 |   }
 63 | }
 64 | 
 65 | r.context.connect = function(connectionString, databaseName, collectionName){
 66 |   queue.close(function(){
 67 |     queue.options.connectionString = connectionString||queue.options.connectionString;
 68 |     queue.options.databaseName = databaseName||queue.options.databaseName;
 69 |     queue.options.queueCollection = collectionName||queue.options.queueCollection;
 70 |     queue.start(function(err){
 71 |       if(err){
 72 |         console.log(err);
 73 |       }
 74 |     });
 75 |   });
 76 | };
 77 | r.context.connect.description = 'Connect to a specific MongoMQ instance to work with';
 78 | 
 79 | r.context.status = function(callback){
 80 |   callback = callback || function(err, results, info){
 81 |     results = results || [];
 82 |     var i, l=results.length;
 83 |     console.log('\r\n-=[Queue Status]=-');
 84 |     for(i=0; i<l; i++){
 85 |       console.log('Event: '+results[i]._id, 'Depth: '+results[i].value);
 86 |     }
 87 |   };
 88 |   queue.status(callback);
 89 | };
 90 | 
 91 | r.context.help = function(methodName){
 92 |   var msg = false;
 93 |   function getParamNames(func) {
 94 |     var funStr = func.toString();
 95 |     return funStr.slice(funStr.indexOf('(')+1, funStr.indexOf(')')).match(/([^\s,]+)/g);
 96 |   }
 97 |   var describe = function(i, prefix){
 98 |     prefix = prefix||'';
 99 |     var result = prefix+funcs[i].name+'('+getParamNames(queue[funcs[i].name])+') - Alias of the queue.'+funcs[i].name+' method\r\n';
100 |     if(funcs[i].description){
101 |       result += prefix+'  -> '+funcs[i].description+'\r\n';
102 |     }
103 |     return result;
104 |   };
105 |   if(methodName){
106 |     var i = false, l = funcs.length, index = false;
107 |     for(i = 0; (i<l)&&(!index); i++){
108 |       if((funcs[i].name===methodName)||(funcs[i].f===methodName)||(funcs[i].a===methodName)){
109 |         index=i;
110 |       }
111 |     }
112 |     if(index){
113 |       msg = describe(index);
114 |     }
115 |   }
116 |   if(!msg){
117 |     msg = 'Built in test methods:\r\n'+
118 |         '  help() - shows this message\r\n'+
119 |         '  connect(connectionString, databaseName, collectionName) - Connect to a specific MongoMQ instance to work with\r\n';
120 |     var i, l = funcs.length;
121 |     for(i = 0; i<l; i++){
122 |       msg += describe(i, '  ');
123 |     }
124 |     msg += '\r\nInstance Data\r\n'+
125 |         '  queue - the global MongoMQ instance\r\n'
126 |         ;
127 |   }
128 |   console.log(msg);
129 |   return '';
130 | };
131 | 
132 | r.context.queue = queue;
133 | 


--------------------------------------------------------------------------------
/lib/QueueMonitor.js:
--------------------------------------------------------------------------------
  1 | var UUID = require('node-uuid');
  2 | 
  3 | var QueueMonitor = module.exports = function(mq, event, options, callback){
  4 |   var self = this;
  5 |   if(typeof(options)==='function'){
  6 |     callback = options;
  7 |     options = {};
  8 |   }
  9 |   self.__defineGetter__('running', function(){
 10 |     return !!(this.cursor||this.cursorStream);
 11 |   });
 12 |   self.__defineGetter__('stopCallback', function(){
 13 |     return this.options.stopCallback||function(){};
 14 |   });
 15 |   self.__defineSetter__('stopCallback', function(callback){
 16 |     this.options.stopCallback = callback;
 17 |   });
 18 |   self.__defineGetter__('startCallback', function(){
 19 |     return this.options.startCallback||function(){};
 20 |   });
 21 |   self.__defineSetter__('startCallback', function(callback){
 22 |     this.options.startCallback = callback;
 23 |   });
 24 |   self.__defineGetter__('errorCallback', function(){
 25 |     return this.options.errorCallback||function(){};
 26 |   });
 27 |   self.__defineSetter__('errorCallback', function(callback){
 28 |     this.options.errorCallback = callback;
 29 |   });
 30 |   options.writeConcern = (options.writeConcern||'').toLowerCase()==='full'?false:(options.writeConcern||'majority');
 31 |   self.event = event;
 32 |   self.mq = mq;
 33 |   self.callback = callback;
 34 |   self.options = options||{};
 35 |   self.start();
 36 | };
 37 | 
 38 | QueueMonitor.prototype.buildSelector = function(cursorFixId){
 39 |   var self = this, event = self.event, dt = new Date(), afterDt = new Date(dt-self.mq.serverTimeOffset), $or, i, l;
 40 |   if(event!=='*'){
 41 |     $or = [{handled: false, event: event}, {handled: {$exists: false}, event: event}, {fix: cursorFixId}];
 42 |   }else{
 43 |     $or = [{handled: false}, {handled: {$exists: false}, fix: {$exists: false}}, {fix: cursorFixId}];
 44 |   }
 45 |   if(self.options.hereOnOut){
 46 |     l = $or.length;
 47 |     for(i=0; i<l; i++){
 48 |       if($or[i].fix!==cursorFixId){
 49 |         $or[i].globalTime = {$gt: afterDt};
 50 |       }
 51 |     }
 52 |   }
 53 |   return {$or: $or};
 54 | };
 55 | QueueMonitor.prototype.buildSelector.description = 'Used internally by start_usingNextObject and start_usingStreams to build the message selector.';
 56 | 
 57 | QueueMonitor.prototype.start_usingNextObject = function(startupCallback){
 58 |   // call out to setup the tailed cursor for us
 59 |   var self = this, cursorFixId = self.cursorFixId = UUID.v4(), mq = self.mq, callback = self.callback, event = self.event;
 60 |   // this is a work around so we don't get runaway handles when there is no records for us to process
 61 |   mq.collection(mq.options.queueCollection, function(err, collection){
 62 |     collection.insert({fix: cursorFixId}, {w: 1}, function(){
 63 |       mq.tailedCursor(mq.options.queueCollection, self.buildSelector(cursorFixId), {$natural: 1}, function(err, cursor){
 64 |         if(err){
 65 |           self.errorCallback(err);
 66 |           startupCallback(err);
 67 |         }else{
 68 |           // start the listener loop
 69 |           self.cursor = cursor;
 70 |           self.next();
 71 |           startupCallback(null, self);
 72 |         }
 73 |       });
 74 |     });
 75 |   });
 76 | };
 77 | QueueMonitor.prototype.start_usingNextObject.description = 'Starts the Queue Monitor in nextObject mode, internal use only.';
 78 | 
 79 | QueueMonitor.prototype.start_usingStreams = function(startupCallback){
 80 |   var self = this, cursorFixId = self.cursorFixId = UUID.v4(), mq = self.mq, callback = self.callback, event = self.event;
 81 |   // this is a work around so we don't get runaway handles when there is no records for us to process
 82 |   mq.collection(mq.options.queueCollection, function(err, collection){
 83 |     if(collection){
 84 |       collection.insert({fix: cursorFixId}, {w: 1}, function(){
 85 |         mq.tailedCursorStream(mq.options.queueCollection, self.buildSelector(cursorFixId), {$natural: 1}, function(err, stream){
 86 |           if(!stream){
 87 |             self.start_usingStreams(startupCallback);
 88 |           }else{
 89 |             self.cursorStream = stream;
 90 |             stream.on("data", function(data){
 91 |               self.handleResponse(null, data);
 92 |             });
 93 |             stream.on("error", function(err){
 94 |               self.errorCallback(err);
 95 |               self.handleResponse(err);
 96 |             });
 97 |             stream.on("close", function(data){
 98 |               self.stop();
 99 |             });
100 |             startupCallback(null, self);
101 |           }
102 |         });
103 |       });
104 |     }else{
105 |       self.start_usingStreams(startupCallback);
106 |     }
107 |   });
108 | };
109 | QueueMonitor.prototype.start_usingStreams.description = 'Starts the Queue Monitor in streaming mode, internal use only.';
110 | 
111 | QueueMonitor.prototype.start = function(callback){
112 |   var self = this, options = self.options;
113 |   var started = function(err, response){
114 |     if(err){
115 |       self.errorCallback(err);
116 |     }else{
117 |       self.startCallback(err, response);
118 |     }
119 |     (callback||function(){})(err, response);
120 |   };
121 |   if(!self.running){
122 |     switch((options.listenerType||'').toLowerCase()){
123 |       case('responselistener'):
124 |       case('streams'):
125 |         self.start_usingStreams(started);
126 |         break;
127 |       case('nextobject'):
128 |       default:
129 |         self.start_usingNextObject(started);
130 |     }
131 |   }else{
132 |     (callback||function(){})(null, self);
133 |   }
134 | };
135 | QueueMonitor.prototype.start.description = 'Starts the Queue Monitor based on the listenerType option provided when created.';
136 | 
137 | QueueMonitor.prototype.restart = function(callback){
138 |   var self = this;
139 |   self.stop(function(){
140 |     self.start(callback);
141 |   });
142 | };
143 | QueueMonitor.prototype.restart.description = 'Stops and restarts the Queue Monitor.';
144 | 
145 | QueueMonitor.prototype.handleResponse = function(err, record, doNext){
146 |   var self = this, cursorFixId = self.cursorFixId, mq = self.mq, callback = self.callback;
147 |   next = function(data){
148 |     if(((record||{}).response_id)&&(typeof(data)!=='undefined')){
149 |       mq.emit(record.response_id, data);
150 |     }
151 |     if(typeof(doNext)==='function'){
152 |       doNext();
153 |     }
154 |   };
155 |   if(err||(!record)){
156 |     if(err){
157 |       // The remote server may have went away,
158 |       // restart the connection just to be sure we
159 |       // get our messages.
160 |       self.errorCallback(err);
161 |       self.restart();
162 |     }else{
163 |       next();
164 |     }
165 |     return;
166 |   }else if(record.handled||record.fix===cursorFixId){
167 |     // If we have a handled record, or the fix record, then skip it
168 |     return next();
169 |   }else{
170 |     if(typeof(record.handled)==='undefined'){
171 |       if(record.fix===cursorFixId){
172 |         // Don't report back the fix record
173 |         next();
174 |       }else{
175 |         // This is to catch broadcast events, actually this breaks things as is
176 |         // so will need to fix that eventually with some type of server time
177 |         // solution
178 |         callback(null, (record||{}).data, next);
179 |       }
180 |     }else{
181 |       mq.collection(mq.options.queueCollection, function(err, collection){
182 |         if(err){
183 |           self.errorCallback(err);
184 |           callback(err, null, next);
185 |         }else{
186 |           // Lock the record so that we can work with it and no one else can
187 |           var set = {$set: {handled: true}};
188 |           if(record.pickedTime){
189 |             var dt = new Date();
190 |             set.$set.pickedTime = new Date(dt-mq.serverTimeOffset)
191 |           }
192 |           if(self.options.passive||mq.options.passive){
193 |             mq.emitter.emit('recieved', record);
194 |             callback(err, (record||{}).data, next);
195 |           }else{
196 |             collection.findAndModify(record, {$natural: -1}, set, {w: ((mq.db||{}).serverConfig||{}).replicaSet?self.options.writeConcern||mq.options.writeConcern||mq.db.serverConfig.servers.length:1}, function(err, data){
197 |               if(data||err){
198 |                 if(err){
199 |                   self.errorCallback(err);
200 |                 }
201 |                 // Different versions of the mongodb driver use different return
202 |                 // object formats for findAndModify. Found data is returned directly
203 |                 // in early versions and as .value in later versions.
204 |                 mq.emitter.emit('recieved', data.value||data);
205 |                 callback(err, (data.value||data||{}).data, next);
206 |               }else{
207 |                 // We didn't get the lock on the record
208 |                 next();
209 |               }
210 |             });
211 |           }
212 |         }
213 |       });
214 |     }
215 |   }
216 | };
217 | QueueMonitor.prototype.handleResponse.description = 'Handles a message when it appears in the queue.';
218 | 
219 | QueueMonitor.prototype.next = function(){
220 |   var self = this, cursor = self.cursor, cursorFixId = self.cursorFixId, mq = self.mq, callback = self.callback;
221 |   var next = function(){
222 |     self.next();
223 |   };
224 | 
225 |   cursor.nextObject(function(err, record){
226 |     if(err){
227 |       self.errorCallback(err);
228 |     }
229 |     self.handleResponse(err, record, next);
230 |   });
231 | };
232 | QueueMonitor.prototype.restart.description = 'Sets the monitor up for the next message.';
233 | 
234 | QueueMonitor.prototype.stop = function(callback){
235 |   var self = this, cursor;
236 |   if(self.cursor||self.cursorStream){
237 |     if(self.cursor){
238 |       self.cursor.close();
239 |       self.cursor = false;
240 |     }
241 |     if(self.cursorStream){
242 |       self.cursorStream.destroy();
243 |       self.cursorStream = false;
244 |     }
245 |     self.stopCallback(null, self);
246 |     (callback||function(){})(null, self);
247 |   }else{
248 |     (callback||function(){})(null, self);
249 |   }
250 | };
251 | QueueMonitor.prototype.restart.description = 'Stops the Queue Monitor.';
252 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
  1 | MongoMQ v0.3.x
  2 | ==============
  3 | 
  4 | Version 0.3.x introduces new functionality and many bug fixes over v0.2.x.  It also introduces some minor changes to packet format and thus is not backwards compatable with v0.2.x
  5 | 
  6 | Biggest differences from 0.2.x to 0.3.x
  7 | =======================================
  8 | 
  9 |   * Partial callbacks were removed.  They didn't serve any purpose.
 10 |   * Large messages are pushed to GridFS (planned feature)
 11 |   * Message format changed, backward compatible for the most part, must turn on the options.support_v2 flag
 12 |   * OnAny has been temporarily removed, *BREAKING CHANGE*
 13 |   * Logging support (started, but not complete/tested)
 14 | 
 15 | Installation
 16 | ============
 17 | 
 18 | From GitHub
 19 | -----------
 20 |   * Download from GitHub and extract.
 21 |   * change to extracted directory
 22 |   * execute "npm install"
 23 | 
 24 | Using NPM
 25 | ---------
 26 |   * npm install mongomq
 27 | 
 28 | Requirements
 29 | ============
 30 |   * Node.js - v0.8.2 or better (really only for the MongoMQ and Test.js scripts REPL support)
 31 |   * MongoDB - v2.1.2 or better (for Tailable Cursors, autoIndexId bug fix, and ReplicaSet fixes)
 32 | 
 33 | What is MongoMQ?
 34 | ================
 35 | 
 36 | MongoMQ is a messaging queue built on top of Node.js and MongoDB's tailable cursors.  It allows for distributed of messages across workers in both a single reciever and broadcast method.
 37 | 
 38 | What MongoMQ is NOT
 39 | ===================
 40 | 
 41 | MongoMQ does NOT (currently) support callback's once a message is processed.  Instead it is recommended that you use a one time listener to pickup responses if this is required.
 42 | 
 43 | Supported Methods
 44 | =================
 45 | 
 46 | new MongoMQ(options)
 47 | --------------------
 48 | 
 49 | MongoMQ.start([callback])
 50 | -------------------------
 51 | 
 52 | Starts the queue listener and sets up the emitter.
 53 | 
 54 | Params:
 55 | * callback - will be called once the queue is opened and all registered listeners are setup
 56 | 
 57 | MongoMQ.stop([callback])
 58 | ------------------------
 59 | 
 60 | Stops listening for messages and closes the emitter.
 61 | 
 62 | Params:
 63 | * callback - will be called once the queue is completely close and all registered listeners have been shut down
 64 | 
 65 | MongoMQ.emit(msgType, data, [completeCallback])
 66 | ------------------------------------------------------------------
 67 | 
 68 | Places the a message of msgTye on the queue with the provided data for handlers to consume.
 69 | 
 70 | Params:
 71 | 
 72 |   * msgType - The message type to emit.
 73 |   * data - a JSON serializeable collection of data to be sent.
 74 |   * completeCallback - Will be called once all remote processing has been completed.
 75 | 
 76 | MongoMQ.on(msgType, [options], handler)
 77 | ---------------------------------------
 78 | 
 79 | Sets up a listener for a specific message type.
 80 | 
 81 | Params:
 82 | 
 83 | * msgType - The message type to listen for can be a string or a regular expression
 84 | * options - additional options that can be passed
 85 | * handler(err, messageContents, next) - Use next() to look for another message in the queue, don't call next() if you only want a one time listener
 86 |     * If you want to send back data or partial data use next(data, complete) where complete should be true if you have sent all of your responses, see test.js r.context.tmp for a simple example.
 87 | 
 88 | options -
 89 | 
 90 | MongoMQ.listeners(event)
 91 | ------------------------------------------
 92 | 
 93 | Provides back an array of listeners that matche the supplied event.  Returns an empty array if no listeners are subscribed to the event.
 94 | 
 95 | Params:
 96 | * event - The name of the event to look for.
 97 | 
 98 | MongoMQ.removeListener(event, handler)
 99 | ------------------------------------------
100 | 
101 | Shuts down the first listener that matches the supplied event and handler and removes it from the listeners list.
102 | 
103 | Params:
104 | * event - The name of the event to look for.
105 | * handler - The specific handler function to look for.
106 | 
107 | MongoMQ.removeAllListeners(event)
108 | ------------------------------
109 | 
110 | Shuts down ALL listeners for the specified event and removes them from the listeners list.
111 | 
112 | Params:
113 | * event - The name of the event to look for.
114 | 
115 | How does MongoMQ work?
116 | ======================
117 | 
118 | MongoMQ sets up a tailable collection and then starts listeners using find in conjunction with findAndModify to pickup messages out of this collection.
119 | 
120 | Since MongoMQ is basically a wrapper around MongoDB's built in support for tailable cursors it is possible to place listeners built in other langauges on the "queue".
121 | 
122 | Sample Usage
123 | ============
124 | 
125 |   * Ensure MongoDB is up and running locally (or modify the config options to collect to your Mongo instance)
126 |   * Start 3 copies of the bin/test.js script.
127 |   * In two copies type listen() to setup a "test" message listener
128 |   * In the 3rd copy type load() to send 100 test messages to the queue
129 |   
130 | You should see the two listeners pickup messages one at a time with whoever has resources to process picking up the message first.
131 | 
132 | bin/test.js
133 | ===========
134 | 
135 | ```javascript
136 | var MongoMQ = require('../lib/MongoMQ').MongoMQ;
137 | var repl = require('repl');
138 | 
139 | var queue = new MongoMQ({
140 |   autoStart: true
141 | });
142 | 
143 | var r = repl.start({
144 |       prompt: "testbed>"
145 |     });
146 | r.on('exit', function(){
147 |   queue.stop();
148 | });
149 | 
150 | var msgidx = 0;
151 | r.context.send = function(){
152 |   queue.emit('test', msgidx);
153 |   msgidx++;
154 | };
155 | 
156 | r.context.load = function(){
157 |   for(var i = 0; i<100; i++){
158 |     queue.emit('test', msgidx);
159 |     msgidx++;
160 |   }
161 | };
162 | 
163 | var logMsg = function(err, data, next){
164 |       console.log('LOG: ', data);
165 |       next();
166 |     };
167 | var eatTest = function(err, data, next){
168 |       console.log('eat: ', data);
169 |       next();
170 |     };
171 | 
172 | r.context.logAny = function(){
173 |   queue.onAny(logMsg);
174 | };
175 | 
176 | r.context.listen = function(){
177 |   queue.on('test', eatTest);
178 | };
179 | 
180 | r.context.start = function(cb){
181 |   queue.start(cb);
182 | };
183 | 
184 | r.context.stop = function(){
185 |   queue.stop();
186 | };
187 | 
188 | r.context.help = function(){
189 |   console.log('Built in test methods:\r\n'+
190 |       '  help()    - shows this message\r\n'+
191 |       '  logAny()  - logs any message to the console\r\n'+
192 |       '  eatTest() - consumes next available "test" message from the queue\r\n'+
193 |       '  send()    - places a "test" message on the queue\r\n'+
194 |       '  load()    - places 100 "test" messages on the queue\r\n'+
195 |       '  start()   - start the queue listener\r\n'+
196 |       '  stop()    - stop the queue listener\r\n'+
197 |       '\r\nInstance Data\r\n'+
198 |       '  queue - the global MongoMQ instance\r\n'
199 |       );
200 |   return '';
201 | };
202 | 
203 | /*
204 | queue.start(function(){
205 |   r.context.eatTest();
206 | });
207 | */
208 | 
209 | r.context.queue = queue;
210 | 
211 | r.context.help();
212 | ```
213 | 
214 | How Events are stored
215 | =====================
216 | 
217 | ```javascript
218 | {
219 |   _id: ObjectId(), // for internal use only
220 |   pkt_ver: 3, // Packet version that this message is being sent in
221 |   event: event, // string that represents what type of event this is
222 |   data: message, // Contains the actual message contents
223 |   handled: false, // states if the message has been handled or not
224 |   localTime: dt, // Local Date Time of when the message was put on the queue
225 |   globalTime: new Date(dt-self.serverTimeOffset), // Date Time offset to server time of when the message was put on the queue
226 |   pickedTime: new Date(dt-self.serverTimeOffset), // Date Time offset to server time of when the message was picked up from the queue
227 |   host: string, // Contains the host name of the machine that initiated the event
228 |   [response_id: string] // optional if the event expects response(s) this will be the conversation identifier used to track those responses
229 | }
230 | ```
231 | 
232 | Update History
233 | ==============
234 | 
235 | v0.3 Update History
236 | -------------------
237 | 
238 | v0.3.4
239 |   * Fix QueueMonitor.js call from options to self.options in handleResponse
240 | 
241 | v0.3.3
242 |   * Fixed package.json and upreved version to pickup changes.
243 | 
244 | v0.3.2
245 |   * Upgraded to latest (1.3.6) version of Mongo Node Native
246 |   * Fixed typo in lib.js for inclusion of Logging (changed Logging to logging)
247 |   * Locked dependency versions so breaking shouldn't happen again when the dependency chain changes
248 | 
249 | v0.3.1
250 |   * Added setTimeout to nextTick on startup to give Mongo a chance to get connceted to
251 |   * Minor bug fix due to EventEmitter treating 'error' events specially
252 |   * Tweak to once listeners to call next if it exists.  Shouldn't change anything but it is good practice.
253 | 
254 | v0.3.0
255 |   * Initial release of v0.3.x, includes many new features and functionality along with many bug fixes.
256 | 
257 | v0.2 Update History
258 | -------------------
259 | 
260 | v0.2.10&v0.2.11
261 |   * Workaround for Mongo Native Driver not supporting tailed cursor auto-reconnects when Mongo server goes away.
262 | 
263 | v0.2.9
264 |   * Change SafeDBDriver default value from false to true, this fixes the issue with multiple listeners picking up the same message since Mongo doesn't perform record locking on updates if this isn't true.
265 |   * Fix autoStart
266 |   * Resolves #9 and #10
267 |   
268 | v0.2.8
269 |   * Upgraded code for new MongoDB Native Drivers (thanks mfrobben for starting points)
270 |   * Readme cleanup (thanks ttezel for pointing this out and fixing it)
271 |   * Resolves #7 and #6
272 | 
273 | v0.2.7
274 |   * Fixed a cursor leak when using passive callbacks
275 | 
276 | v0.2.6
277 |   * Bug fix related to relplica set configuration loading from config.json files
278 | 
279 | v0.2.5
280 |   * General code cleanup and optimizations
281 |   * Examples cleanup and fixes
282 | 
283 | v0.2.4
284 |   * Examples added
285 | 
286 | v0.2.3
287 |   * Minor bug fix related to passive listeners where a fromDT was not passed in the options
288 |   * Added hostName to messages for better tracking/logging
289 |   * Modified passive callback to pass the actual message as the "this" argument, you can now use this.event to get the actual event that was responded to
290 |   * Updated the on() method to accept strings or regular expressions to filter events on
291 | 
292 | v0.2.2
293 |   * Completed code to allow for callbacks and partial callbacks to be issued back to emit statements
294 |   * Complteed refactoring of code to properly seperate functionality into objects
295 | 
296 | v0.2.1
297 |   * Majorly refactored code
298 |   * Added autoIndexId: true to queue collection creation
299 |   * Better MongoMQ application with help()
300 |   * Updated test application
301 |   * Added an exception to emit() when you try to emit before start() has been called
302 |   * fix to onAny so it will restart listeners after a close() and start() re-issue
303 |   * Added remove*() methods
304 |   * Changed close() to stop()
305 |   * hereOnOut options - allows listeners to only pay attention to messages posted after they have been started up
306 |   * Added ability to register listeners (via on and onAny) when queue is not started
307 | 
308 | v0.1.1
309 |   * Bug fixes to on event
310 |   * Added in new onAny register
311 |   * Migrated code to retain cursor
312 |   
313 | v0.1.0
314 |   * Initial release
315 |   * More of a proof of concept


--------------------------------------------------------------------------------
/lib/MongoMQ.js:
--------------------------------------------------------------------------------
  1 | var MC = require('./MongoConnection');
  2 | var UUID = require('node-uuid');
  3 | var util = require('util');
  4 | var Options = require('./options');
  5 | var hostName = require('os').hostname();
  6 | var QueueMonitor = require('./QueueMonitor');
  7 | var errors = require('./errors');
  8 | 
  9 | var defaults = {
 10 |   autoStart: true,
 11 |   queueCollection: 'queue',
 12 |   databaseName: 'mongomq'
 13 | };
 14 | 
 15 | var MongoMQ = module.exports = function(options, callback){
 16 |   var self = this, mcOptions;
 17 |   if(typeof(options)==='function'){
 18 |     callback = options;
 19 |     options = {};
 20 |   }
 21 |   callback=callback||function(){};
 22 |   options = options||{};
 23 |   options.databaseName=options.databaseName||options.database;
 24 |   options.queueCollection=options.queueCollection||options.collectionName;
 25 |   options = Options.ensure(options, defaults);
 26 | 
 27 |   mcOptions = Options.ensure(mcOptions, options);
 28 |   mcOptions.autoStart = false;
 29 | 
 30 |   MC.call(self, options);
 31 | 
 32 |   self.monitors={};
 33 |   self.emitter.surface(['ready', 'stopped']);
 34 | 
 35 |   if(options.autoStart){
 36 |     self.start(callback);
 37 |   }else{
 38 |     callback(null, self);
 39 |   }
 40 | };
 41 | 
 42 | util.inherits(MongoMQ, MC);
 43 | 
 44 | MongoMQ.options = defaults;
 45 | 
 46 | MongoMQ.prototype.checkConnection = function(callback){
 47 |   var self = this;
 48 |   var waitForStarted = function(){
 49 |     process.nextTick(function(){
 50 |       setTimeout(function(){
 51 |         if(self.isopen){
 52 |           callback(null, self);
 53 |         }else{
 54 |           waitForStarted();
 55 |         }
 56 |       }, 100);
 57 |     });
 58 |   };
 59 |   if(self.isopen){
 60 |     callback(null, self);
 61 |   }else if(self.options.autoStart){
 62 |     waitForStarted();
 63 |   }else{
 64 |     callback(new Error(errors.E_CONNCLOSED));
 65 |   }
 66 | };
 67 | MongoMQ.prototype.checkConnection.description = 'Checks to see if MongoMQ is connected to a server or not.';
 68 | 
 69 | MongoMQ.prototype.start = function(callback){
 70 |   var self = this;
 71 |   if(self.isopen){
 72 |     (callback||function(){})(null, self);
 73 |   }else{
 74 |     self.open(function(err){
 75 |       if(err){
 76 |         self.close();
 77 |         self._open = false;
 78 |         (callback||function(){})(err);
 79 |         self.emitter.call('error', err);
 80 |       }else{
 81 |         self.ensureCapped(self.options.queueCollection, function(err, collection){
 82 |           if(!self.emitter.checkNoError(err, callback)){
 83 |             self.close();
 84 |             self._open = false;
 85 |           }else{
 86 |             self.startListeners(function(){
 87 |               var startTime = new Date();
 88 |               self.serverStatus(function(err, status){
 89 |                 if(self.emitter.checkNoError(err, callback)){
 90 |                   self.serverTimeOffset = status.localTime - startTime;
 91 |                   (callback||function(){})(err, self);
 92 |                   self.emitter.call('ready', err);
 93 |                 }
 94 |               });
 95 |             });
 96 |           }
 97 |         });
 98 |       }
 99 |     });
100 |   }
101 | };
102 | MongoMQ.prototype.start.description = 'Starts the Mongo Queue system.';
103 | 
104 | MongoMQ.prototype.stop = function(callback){
105 |   var self = this;
106 |   if(self.isopen){
107 |     self.stopListeners(function(){
108 |       self.close(function(){
109 |         self.emitter.call('stopped');
110 |         self._open = false;
111 |         (callback||function(){})(null, self);
112 |       });
113 |     });
114 |   }else{
115 |     (callback||function(){})(null, self);
116 |     self.emitter.call('stopped');
117 |   }
118 | };
119 | MongoMQ.prototype.start.description = 'Stops the Mongo Queue system.';
120 | 
121 | MongoMQ.prototype.emit = function(event, message, callback){
122 |   var self = this, hasCallback = typeof(callback)==='function';
123 |   self.checkConnection(function(err){
124 |     if(err){
125 |       self.emitter.call('error', err);
126 |       if(typeof(callback)==='function'){
127 |         return callback(err);
128 |       }else{
129 |         throw err;
130 |       }
131 |     }
132 |     self.collection(self.options.queueCollection, function(err, collection){
133 |       var dt = new Date(),
134 |           pkt = {
135 |             pkt_ver: 3,
136 |             event: event,
137 |             data: message,
138 |             handled: false,
139 |             localTime: dt,
140 |             globalTime: new Date(dt-self.serverTimeOffset),
141 |             pickedTime: new Date(dt-self.serverTimeOffset),
142 |             host: hostName
143 |           };
144 |       if(hasCallback){
145 |         pkt.response_id = UUID.v4(); // new way
146 |         if(self.options.support_v2){
147 |           pkt.conversationId = UUID.v4(); // old way
148 |         }
149 |       }
150 |       collection.insert(pkt, {w: 1}, function(err, details){
151 |         self.emitter.call('sent', details);
152 |         if(!err){
153 |           if(hasCallback){
154 |             self.once(pkt.response_id, {listenerType: 'responseListener'}, callback);
155 |           }
156 |         }else{
157 |           //err = err instanceof Error?err:new Error(err);
158 |           self.emitter.call('error', err);
159 |           if(hasCallback){
160 |             callback(err);
161 |           }else{
162 |             throw err;
163 |           }
164 |         }
165 |       });
166 |     });
167 |   });
168 | };
169 | MongoMQ.prototype.emit.description = 'Puts a message on the queue.';
170 | 
171 | MongoMQ.prototype.broadcast = function(event, message){
172 |   var self = this;
173 |   self.checkConnection(function(err){
174 |     if(err){
175 |       self.emitter.call('error', err);
176 |       throw err;
177 |     }
178 |     self.collection(self.options.queueCollection, function(err, collection){
179 |       var pkt = {
180 |         event: event,
181 |         data: message,
182 |         localTime: new Date(),
183 |         host: hostName
184 |       };
185 |       collection.insert(pkt, {w: 0});
186 |     });
187 |   });
188 | };
189 | MongoMQ.prototype.broadcast.description = 'Broadcasts a message out across all subscribed listeners.';
190 | 
191 | MongoMQ.prototype.status = function(callback){
192 |   var self = this;
193 |   if(self.isopen){
194 |     self.checkConnection(function(err){
195 |       if(err){
196 |         self.emitter.call('error', err);
197 |         if(typeof(callback)==='function'){
198 |           return callback(err);
199 |         }else{
200 |           throw err;
201 |         }
202 |       }
203 |       var map = function(){
204 |         emit(this.event, 1);
205 |       };
206 |       var reduce = function(key, values){
207 |         var reduced = 0;
208 |         values.forEach(function(val){
209 |           reduced += val;
210 |         });
211 |         return reduced;
212 |       };
213 |       self.collection(self.options.queueCollection, function(err, collection){
214 |         if(err){
215 |           self.emitter.call('error', err);
216 |           callback(err);
217 |         }else{
218 |           collection.mapReduce(map, reduce, {
219 |             query : { "handled" : false },
220 |             out : { inline : 1 }
221 |           }, callback);
222 |         }
223 |       });
224 |     });
225 |   }else{
226 |     callback(null, false);
227 |   }
228 | };
229 | MongoMQ.prototype.status.description = 'Retrieves the MongoMQ queue stati and their depth.';
230 | 
231 | MongoMQ.prototype.startListeners = function(callback){
232 |   var self = this, eventNames = Object.keys(self.monitors), i, l=eventNames.length, detailItems, j, k;
233 |   for(i=0; i<l; i++){
234 |     detailItems = self.monitors[eventNames[i]];
235 |     k = detailItems.length;
236 |     for(j=0; j<k; j++){
237 |       self.on(eventNames[i], detailItems[j].options, detailItems[j].callback);
238 |     }
239 |   }
240 |   callback(null, self);
241 | };
242 | MongoMQ.prototype.startListeners.description = 'Starts the queue listeners that have not yet been started.';
243 | 
244 | MongoMQ.prototype.stopListeners = function(callback){
245 |   var self = this, eventNames = Object.keys(self.monitors), i, l=eventNames.length, detailItems, j, k, toStop=0;
246 |   var checkStopped = function(){
247 |     if(toStop<=0){
248 |       callback(null, self);
249 |     }else{
250 |       process.nextTick(checkStopped);
251 |     }
252 |   };
253 | 
254 |   for(i=0; i<l; i++){
255 |     detailItems = self.monitors[eventNames[i]];
256 |     k = detailItems.length;
257 |     toStop = k;
258 |     for(j=0; j<k; j++){
259 |       if(detailItems[j].monitor){
260 |         detailItems[j].monitor.stop(function(){
261 |           toStop--;
262 |         });
263 |       }else{
264 |         toStop--;
265 |       }
266 |     }
267 |   }
268 |   checkStopped();
269 | };
270 | MongoMQ.prototype.stopListeners.description = 'Stops the queue listeners that have not yet been stopped.';
271 | 
272 | 
273 | MongoMQ.prototype.onAny = function(options, callback){
274 |   var self = this;
275 |   if(typeof(options)==='function'){
276 |     callback = options;
277 |     options = {};
278 |   }
279 |   options=options||{};
280 |   options.listenerType = options.listenerType||'streams';
281 |   options.hereOnOut = typeof(options.hereOnOut)!=='undefined'?options.hereOnOut:true;
282 |   options.passive = true;
283 |   self.on('*', options, callback);
284 | };
285 | MongoMQ.prototype.onAny.description = 'Listens for any message on the message queue in a passive mode.';
286 | 
287 | MongoMQ.prototype.on = MongoMQ.prototype.addListener = function(event, options, callback){
288 |   var self = this;
289 |   var list = self.monitors[event]=self.monitors[event]||[], i, l=list.length, index=false;
290 |   if(typeof(options)==='function'){
291 |     callback = options;
292 |     options = {};
293 |   }
294 |   options=options||{};
295 |   for(i=0; (i<l)&&(index===false); i++){
296 |     if(list[i].callback === callback){
297 |       index = i;
298 |     }
299 |   }
300 |   if(index===false){
301 |     index = list.length;
302 |     list.push({options: options, callback: callback});
303 |   }
304 |   if(self.isopen){
305 |     if(!list[index].monitor){
306 |       list[index].monitor = new QueueMonitor(self, event, options, callback);
307 |     }else{
308 |       list[index].monitor.start();
309 |     }
310 |   }
311 | };
312 | MongoMQ.prototype.on.description = 'Adds a listener for a specific event.';
313 | 
314 | MongoMQ.prototype.once = function(event, options, callback){
315 |   var self = this;
316 |   if(typeof(options)==='function'){
317 |     callback = options;
318 |     options = {};
319 |   }
320 |   options=options||{};
321 |   var monitor = new QueueMonitor(self, event, options, function(err, response, next){
322 |     if(err){
323 |       self.emitter.call('error', err);
324 |     }
325 |     (callback||function(){})(err, response);
326 |     monitor.stop();
327 |   });
328 | };
329 | MongoMQ.prototype.once.description = 'Adds a one time listener for a specific event.';
330 | 
331 | MongoMQ.prototype.removeListener = function(event, callback){
332 |   var self = this;
333 |   var list = self.monitors[event]=self.monitors[event]||[], i, l=list.length, listener;
334 |   for(i=0; i<l; i++){
335 |     if(list[i].callback === callback){
336 |       listener = list.splice(i, 1);
337 |       listener.stop();
338 |       return listener;
339 |     }
340 |   }
341 |   return false;
342 | };
343 | MongoMQ.prototype.removeListener.description = 'Stops and removes a specific listener from the event.';
344 | 
345 | MongoMQ.prototype.removeAllListeners = function(event){
346 |   var self = this;
347 |   var list = self.monitors[event]=self.monitors[event]||[], i, l=list.length, listener;
348 |   for(i=l; i>-1; i--){
349 |     listener = list[i].stop();
350 |   }
351 |   self.monitors[event]=[];
352 | };
353 | MongoMQ.prototype.removeAllListeners.description = 'Stops and removes all listeners for a specific event.';
354 | 
355 | MongoMQ.prototype.setMaxListeners = false;
356 | 
357 | MongoMQ.prototype.listeners = function(event){
358 |   var self = this;
359 |   var list = self.monitors[event]=self.monitors[event]||[];
360 |   return list;
361 | };
362 | MongoMQ.prototype.listeners.description = 'Returns a listing of listeners and their options for a given event.';
363 | 


--------------------------------------------------------------------------------
/lib/MongoConnection.js:
--------------------------------------------------------------------------------
  1 | var Mongo = require('mongodb');
  2 | var Mongo = require('mongodb');
  3 | var MongoClient = Mongo.MongoClient;
  4 | var Options = require('./options');
  5 | var GridStore = Mongo.GridStore;
  6 | var Eventer = require('./eventer');
  7 | var errors = require('./errors');
  8 | 
  9 | var defaults = {
 10 |       CollectionOptions: {safe: false},
 11 |       ServerHost: 'localhost',
 12 |       ServerOptions: {
 13 |         auto_reconnect: false,
 14 |         //*
 15 |         poolSize: 1,
 16 |         socketOptions: {
 17 |           connectTimeoutMS: 1000,
 18 |           socketTimeoutMS: 1000
 19 |         }
 20 |         //*/
 21 |       },
 22 |       CappedCollectionSize: 104857600,
 23 |       NativeParser : false,
 24 |       logger: null // No logger by default.  If providied, this needs to have the same interface as the MongoDB logger.
 25 |       //logger: new require('./logger')()
 26 |     };
 27 | 
 28 | var ensureMongoConnectionDetails = function(options){
 29 |   if(options.connectionString){
 30 |     return;
 31 |   }else if(options.servers||options.host){
 32 |     Options.ensure(options, {port: 27017});
 33 |     return;
 34 |   }else{
 35 |     options.connectionString = 'mongodb://localhost:27017';
 36 |   }
 37 | };
 38 | 
 39 | var MongoConnection = module.exports = function(options, callback){
 40 |   var self = this, dbName;
 41 |   callback=callback||function(){};
 42 |   options = Options.ensure(options||{}, {autoStart: true});
 43 |   ensureMongoConnectionDetails(options);
 44 |   self.__defineGetter__('options', function(){
 45 |     return options;
 46 |   });
 47 |   self.__defineGetter__('active', function(){
 48 |     return (!!this.db)&&(this.db.openCalled);
 49 |   });
 50 |   self.__defineGetter__('isopen', function(){
 51 |     return this._open;
 52 |   });
 53 |   self.__defineGetter__('databaseName', function(){
 54 |     return (this.db||{}).databaseName||'default';
 55 |   });
 56 |   self.__defineSetter__('databaseName', function(value){
 57 |     this.use(value);
 58 |   });
 59 |   self.emitter = new Eventer(self);
 60 |   self.emitter.surface(['error', 'opened', 'closed']);
 61 |   self.emitter.registerTo(self);
 62 | };
 63 | 
 64 | MongoConnection.ERROR_CODES = errors;
 65 | 
 66 | var connect = function(self, connection, callback){
 67 |   var connected = function(err, database){
 68 |       if(self.emitter.checkNoError(err, callback)){
 69 |         self.db = database;
 70 |         self._open = true;
 71 |         if(self.options.username&&self.options.password){
 72 |           if(self.options.authenticateAgainstDb){
 73 |             database.authenticate(self.options.username, self.options.password, function(err, result){
 74 |               if(typeof(callback)=='function'){
 75 |                 self.emitter.call('opened', err);
 76 |                 callback(null, self);
 77 |               }
 78 |             });
 79 |           }else{
 80 |             database.admin(function(err, adminDb){
 81 |               if(self.emitter.checkNoError(err, callback)){
 82 |                 adminDb.authenticate(self.options.username, self.options.password, function(err, result){
 83 |                   if(self.emitter.checkNoError(err, callback)){
 84 |                     self.emitter.call('opened', err);
 85 |                     callback(null, self);
 86 |                   }
 87 |                 });
 88 |               }
 89 |             });
 90 |           }
 91 |         }else{
 92 |           self.emitter.call('opened', err);
 93 |           callback(null, self);
 94 |         }
 95 |       }
 96 |     };
 97 |   if(!connection){
 98 |     var connectOptions = {server: Options.ensure(self.options.serverOptions||{}, defaults.ServerOptions)};
 99 |     if(self.options.logger||defaults.logger){
100 |       connectOptions.server.logger=self.options.logger||defaults.logger;
101 |       connectOptions.server.logger.log('Logger setup');
102 |     }
103 |     connectOptions.server.auto_reconnect = null;
104 |     MongoClient.connect(self.options.connectionString, connectOptions, connected);
105 |   }else{
106 |     self.mongoClient = new MongoClient(connection);
107 |     self.mongoClient.open(connected);
108 |   }
109 | };
110 | 
111 | var connectReplSet = function(self, options, callback){
112 |   var l = options.servers.length, server, serverConfig, serverConnection;
113 |   var servers = [], serverOptions = Options.ensure(options.serverOptions||{}, defaults.ServerOptions);
114 |   for(var i = 0; i<l; i++){
115 |     serverConfig = options.servers[i];
116 |     if(typeof(serverConfig)=='string'){
117 |       serverConfig = {host: serverConfig, port: options.port||Mongo.Connection.DEFAULT_PORT};
118 |     }else if(typeof(serverConfig) === 'number' && isFinite(serverConfig)){
119 |       serverConfig = {host: defaults.ServerHost, port: serverConfig};
120 |     }
121 |     server = {
122 |         host: serverConfig.host || defaults.ServerHost,
123 |         port: serverConfig.port || options.port || Mongo.Connection.DEFAULT_PORT
124 |       };
125 |     servers.push(new Mongo.Server(server.host, server.port, serverOptions));
126 |   }
127 |   connect(self, Mongo.ReplSet(servers), callback);
128 | };
129 | 
130 | var connectHost = function(self, options, callback){
131 |   self.options.connectionString = 'mongodb://'+(options.host||defaults.ServerHost)+':'+(options.port||Mongo.Connection.DEFAULT_PORT);//'mongodb://localhost:27017';
132 |   connect(self, false, callback);
133 | };
134 | 
135 | MongoConnection.prototype.open = function(callback){
136 |   var self = this, options = self.options;
137 |   var switchToDb = function(err, database){
138 |     if(self.emitter.checkNoError(err, callback)){
139 |       self.use(self.options.databaseName||self.databaseName, callback);
140 |     }
141 |   };
142 |   if(options.connectionString){
143 |     connect(self, false, switchToDb);
144 |   }else if(options.servers){
145 |     connectReplSet(self, options, switchToDb);
146 |   }else if(options.host){
147 |     connectHost(self, options, switchToDb);
148 |   }
149 | };
150 | MongoConnection.prototype.open.description = 'Connects to the MongoDB instance.';
151 | 
152 | MongoConnection.prototype.close = function(callback){
153 |   var self = this;
154 |   var db = self.db;
155 |   if(self._open){
156 |     self._open = false;
157 |     self.db = false;
158 |     if(self.active){
159 |       db.close(callback);
160 |     }else{
161 |       (callback||function(){})(null, self);
162 |     }
163 |     if(self.mongoClient){
164 |       self.mongoClient.close();
165 |       self.mongoClient = false;
166 |     }
167 |     self.emitter.call('closed');
168 |   }
169 | };
170 | MongoConnection.prototype.close.description = 'Closes the connection to the MongoDB instance.';
171 | 
172 | MongoConnection.prototype.checkConnection = function(callback){
173 |   var self = this;
174 |   if(self.isopen){
175 |     callback(null, self);
176 |   }else{
177 |     callback(new Error(errors.E_CONNCLOSED));
178 |   }
179 | };
180 | MongoConnection.prototype.checkConnection.description = 'Validates that a connection with MongoDB has been established.';
181 | 
182 | MongoConnection.prototype.serverStatus = function(callback){
183 |   var self = this;
184 |   self.checkConnection(function(err){
185 |     if(self.emitter.checkNoError(err, callback)){
186 |       self.db.command({serverStatus: 1}, callback);
187 |     }
188 |   });
189 | };
190 | MongoConnection.prototype.serverStatus.description = 'Returns the MongoDB serverStatus().';
191 | 
192 | MongoConnection.prototype.use = function(databaseName, callback){
193 |   var self = this;
194 |   if(self.databaseName !== databaseName){
195 |     self.checkConnection(function(err){
196 |       if(self.emitter.checkNoError(err, callback)){
197 |         /*
198 |         if(self.db){
199 |           self.db.close(); // This line causes a problem with 1.3.6
200 |         }
201 |         */
202 |         self.db = self.db.db(databaseName);
203 |         if(self.options.databaseName){
204 |           self.options.databaseName = databaseName;
205 |         }
206 |         callback(null, self);
207 |       }
208 |     });
209 |   }else{
210 |     callback(null, self);
211 |   }
212 | };
213 | MongoConnection.prototype.use.description = 'Switches to the provided database.';
214 | 
215 | MongoConnection.prototype.collection = function(collectionName, callback){
216 |   var self = this;
217 |   self.checkConnection(function(err){
218 |     if(self.emitter.checkNoError(err, callback)){
219 |       self.db.collection(collectionName, callback);
220 |     }
221 |   });
222 | };
223 | MongoConnection.prototype.collection.description = 'Returns the requested collection.';
224 | 
225 | MongoConnection.prototype.createCollection = function(collectionName, options, callback){
226 |   var self = this;
227 |   self.checkConnection(function(err){
228 |     if(self.emitter.checkNoError(err, callback)){
229 |       if(typeof(options)=='function'){
230 |         callback = options;
231 |         options = {};
232 |       }
233 |       callback = callback || function(){};
234 |       self.db.createCollection(collectionName, options, callback);
235 |     }
236 |   });
237 | };
238 | MongoConnection.prototype.createCollection.description = 'Creates a new collection.';
239 | 
240 | MongoConnection.prototype.ensureCapped = function(collectionName, size, options, callback){
241 |   var self = this;
242 |   self.checkConnection(function(err){
243 |     if(self.emitter.checkNoError(err, callback)){
244 |       if(typeof(size)==='function'){
245 |         callback = size;
246 |         size = false;
247 |         options = {};
248 |       }
249 |       if(typeof(options)==='function'){
250 |         callback = options;
251 |         options = {};
252 |       }
253 |       var collOptions = options || {};
254 |       self.collection(collectionName, function(err, collection){
255 |         if(self.emitter.checkNoError(err, callback)){
256 |           if(typeof(collOptions.autoIndexId)=='undefined'){
257 |             collOptions.autoIndexId = true;
258 |           }
259 |           collOptions.capped = true;
260 |           collOptions.size = collOptions.size||size||defaults.CappedCollectionSize;
261 |           if(!collection){
262 |             self.createCollection(collectionName, collOptions, callback);
263 |           }else{
264 |             collection.isCapped(function(err, capped){
265 |               if(err && err.toString().indexOf('not found')>-1){
266 |                 return self.createCollection(collectionName, collOptions, callback);
267 |               }
268 |               if(self.emitter.checkNoError(err, callback)){
269 |                 if(!!capped){
270 |                   if(typeof(callback)==='function'){
271 |                     callback(null, collection);
272 |                   }
273 |                 }else{
274 |                   collection.insert({workaround: 'This works around a bug with capping empty collections.'}, {safe:true},  function(){
275 |                     self.db.command({"convertToCapped": collectionName, size: collOptions.size}, function(err, result){
276 |                       if(self.emitter.checkNoError(err, callback)){
277 |                         if(typeof(callback)==='function'){
278 |                           if(self.emitter.checkNoError(err, callback)){
279 |                             if (result.ok===0){
280 |                               self.emitter.checkNoError(result.errmsg, callback);
281 |                             }else{
282 |                               self.collection(collectionName, callback);
283 |                             }
284 |                           }
285 |                         }
286 |                       }
287 |                     });
288 |                   });
289 |                 }
290 |               }
291 |             });
292 |           }
293 |         }
294 |       });
295 |     }
296 |   });
297 | };
298 | MongoConnection.prototype.ensureCapped.description = 'Ensures that the provided collection is capped.';
299 | 
300 | MongoConnection.prototype.tailedCursorStreamable = function(collectionName, filter, sort, callback){
301 |   var self = this;
302 |   self.checkConnection(function(err){
303 |     if(self.emitter.checkNoError(err, callback)){
304 |       if(typeof(sort)==='function'){
305 |         callback = sort;
306 |         sort = false;
307 |       }
308 |       if(typeof(callback)!=='function'){
309 |         throw new Error(errors.E_NOCALLBACK);
310 |       }else if(typeof(filter)!=='object'){
311 |         return callback(new Error(errors.E_INVALIDFILTER));
312 |       }else{
313 |         self.collection(collectionName, function(err, collection){
314 |           if(self.emitter.checkNoError(err, callback)){
315 |             collection.isCapped(function(err, capped){
316 |               if(self.emitter.checkNoError(err, callback)){
317 |                 if(capped){
318 |                   var cursorOptions = {tailable: true};
319 |                   if(sort) cursorOptions.sort = sort;
320 |                   callback(null, collection.find(filter, cursorOptions));
321 |                 }else{
322 |                   self.emitter.checkNoError(errors.E_INVALIDCURSORCOLLECTION, callback);
323 |                 }
324 |               }
325 |             });
326 |           }
327 |         });
328 |       }
329 |     }
330 |   });
331 | };
332 | MongoConnection.prototype.tailedCursorStreamable.description = 'Returns a tailed cursor that can be used to create a stream that can be used to monitor the provided collection.';
333 | 
334 | MongoConnection.prototype.tailedCursorStream = function(collectionName, filter, sort, callback){
335 |   var self = this;
336 |   self.checkConnection(function(err){
337 |     if(self.emitter.checkNoError(err, callback)){
338 |       if(typeof(sort)==='function'){
339 |         callback = sort;
340 |         sort = false;
341 |       }
342 |       if(typeof(callback)!=='function'){
343 |         self.emitter.checkNoError(errors.E_NOCALLBACK);
344 |       }else if(typeof(filter)!=='object'){
345 |         self.emitter.checkNoError(new Error(errors.E_INVALIDFILTER), callback);
346 |       }else{
347 |         self.collection(collectionName, function(err, collection){
348 |           if(self.emitter.checkNoError(err, callback)){
349 |             collection.isCapped(function(err, capped){
350 |               if(self.emitter.checkNoError(err, callback)){
351 |                 if(capped){
352 |                   var cursorOptions = {tailable: true};
353 |                   if(sort) cursorOptions.sort = sort;
354 |                   var cursor = collection.find(filter, cursorOptions);
355 |                   var stream = cursor.stream();
356 |                   stream.cursor = cursor;
357 |                   callback(null, stream);
358 |                 }else{
359 |                   self.emitter.checkNoError(errors.E_INVALIDCURSORCOLLECTION, callback);
360 |                 }
361 |               }
362 |             });
363 |           }
364 |         });
365 |       }
366 |     }
367 |   });
368 | };
369 | MongoConnection.prototype.tailedCursorStream.description = 'Returns a tailed stream that can be used to monitor the provided collection.';
370 | 
371 | MongoConnection.prototype.tailedCursor = function(collectionName, filter, sort, callback){
372 |   var self = this;
373 |   self.checkConnection(function(err){
374 |     if(self.emitter.checkNoError(err, callback)){
375 |       if(typeof(sort)==='function'){
376 |         callback = sort;
377 |         sort = false;
378 |       }
379 |       if(typeof(callback)!=='function'){
380 |         self.emitter.checkNoError(errors.E_NOCALLBACK);
381 |       }else if(typeof(filter)!=='object'){
382 |         self.emitter.checkNoError(errors.E_INVALIDFILTER, callback);
383 |       }else{
384 |         self.collection(collectionName, function(err, collection){
385 |           if(self.emitter.checkNoError(err, callback)){
386 |             collection.isCapped(function(err, capped){
387 |               if(self.emitter.checkNoError(err, callback)){
388 |                 if(capped){
389 |                   var cursorOptions = {tailable: true};
390 |                   if(sort) cursorOptions.sort = sort;
391 |                   collection.find(filter, cursorOptions, callback);
392 |                 }else{
393 |                   self.emitter.checkNoError(errors.E_INVALIDCURSORCOLLECTION, callback);
394 |                 }
395 |               }
396 |             });
397 |           }
398 |         });
399 |       }
400 |     }
401 |   });
402 | };
403 | MongoConnection.prototype.tailedCursor.description = 'Returns cursor that can be used with nextObject to monitor a collection.';
404 | 
405 | MongoConnection.prototype.writeGridFS = function(fileName, data, options, callback){
406 |   var self = this;
407 |   if(typeof(options)==='function'){
408 |     callback = options;
409 |     options = {};
410 |   }
411 |   self.checkConnection(function(err){
412 |     if(self.emitter.checkNoError(err, callback)){
413 |     }
414 |   });
415 | };
416 | 
417 | MongoConnection.prototype.readGridFS = function(fileName, options, callback){
418 |   var self = this;
419 |   if(typeof(options)==='function'){
420 |     callback = options;
421 |     options = {};
422 |   }
423 |   self.checkConnection(function(err){
424 |     if(self.emitter.checkNoError(err, callback)){
425 |       GridStore.exist(self.db, fileName, function(err, exists){
426 |         if(self.emitter.checkNoError(err, callback)){
427 |           if(exists===false){
428 |             callback(null, false);
429 |           }else{
430 |             var gridStore = new GridStore(self.db, fileName, 'r');
431 |             gridStore.open(function(err, gridStore) {
432 |               if(self.emitter.checkNoError(err, callback)){
433 |                 gridStore.read(function(err){
434 |                   if(self.emitter.checkNoError(err, callback)){
435 |                     callback.apply(self, arguments);
436 |                     gridStore.close(function(){});
437 |                   }
438 |                 });
439 |               }
440 |             });
441 |           }
442 |         }
443 |       });
444 |     }
445 |   });
446 | };
447 | MongoConnection.prototype.readGridFS.description = 'Retrieves the requested file from GridFS.';
448 | 
449 | MongoConnection.prototype.streamGridFS = function(fileName, callback){
450 |   var self = this;
451 |   self.checkConnection(function(err){
452 |     if(self.emitter.checkNoError(err, callback)){
453 |       GridStore.exist(self.db, fileName, function(err, exists){
454 |         if(self.emitter.checkNoError(err, callback)){
455 |           if(!exists){
456 |             callback(null, false);
457 |           }else{
458 |             var gridStore = new GridStore(self.db, fileName, 'r');
459 |             var doput = function(done){
460 |               return function(data){
461 |                 if(data){
462 |                   callback(null, data.toString());
463 |                 }
464 |                 if(done){
465 |                   callback(null, null);
466 |                 }
467 |               };
468 |             };
469 |             var doerror = function(done){
470 |               return function(err){
471 |                 self.emitter.checkNoError(err, callback);
472 |               };
473 |             };
474 |             gridStore.open(function(err, gridStore) {
475 |               var stream = gridStore.stream(true);
476 |               stream.on('data', doput(false));
477 |               stream.on('error', doerror(true));
478 |               stream.on('end', doput(true));
479 |             });
480 |           }
481 |         }
482 |       });
483 |     }
484 |   });
485 | };
486 | MongoConnection.prototype.streamGridFS.description = 'Retrieves the requested file from GridFS using streams to lower overhead.';
487 | 


--------------------------------------------------------------------------------