mongodb 1.3.14 → 1.3.19

package/Readme.md

@@ -131,7 +131,7 @@ For more information have a look at [Gridstore](https://github.com/mongodb/node-
 
 Replicasets
 ===========
-For more information about how to connect to a replicaset have a look at [Replicasets](https://github.com/mongodb/node-mongodb-native/blob/master/docs/replicaset.md)
+For more information about how to connect to a replicaset have a look at the extensive documentation [Documentation](http://mongodb.github.com/node-mongodb-native/)
 
 Primary Key Factories
 ---------------------

package/lib/mongodb/collection.js

@@ -583,13 +583,16 @@ Collection.prototype.count = function count (query, options, callback) {
   if(typeof limit == 'number') commandObject.limit = limit;
 
   // Set read preference if we set one
-  options.readPreference = _getReadConcern(this, options);
+  var readPreference = _getReadConcern(this, options);
 
   // Execute the command
-  this.db.command(commandObject, options, function(err, result) {
-    if(err) return callback(err, null);
-    return callback(null, result.n);
-  });
+  this.db._executeQueryCommand(DbCommand.createDbSlaveOkCommand(this.db, commandObject)
+    , {read: readPreference}
+    , utils.handleSingleCommandResultReturn(null, null, function(err, result) {
+      if(err) return callback(err, null);
+      if(result == null) return callback(new Error("no result returned for count"), null);
+      callback(null, result.n);
+    }));
 };
 
 
@@ -667,7 +670,7 @@ Collection.prototype.findAndModify = function findAndModify (query, sort, doc, o
   this.db._executeQueryCommand(command
     , {read:false}, utils.handleSingleCommandResultReturn(null, null, function(err, result) {
       if(err) return callback(err, null);
-      return callback(null, result.value, result[0]);
+      return callback(null, result.value, result);
     }));
 }
 

package/lib/mongodb/connection/base.js

@@ -195,33 +195,33 @@ DbStore.prototype.fetch = function(databaseName) {
 DbStore.prototype.emit = function(event, message, object, reset, filterDb, rethrow_if_no_listeners) {
   var emitted = false;
 
-  if(reset) {
-    while(this._dbs.length > 0) {
-      var db = this._dbs.shift();
-      // Only emit if there is a listener
-      if(db.listeners(event).length > 0) {
-        if(filterDb == null  || filterDb.databaseName !== db.databaseName 
-          || filterDb.tag !== db.tag) {
-          db.emit(event, message, object == null ? db : object);
-          emitted = true;
-        }
-      }
-    }
-  } else {
-    for(var i = 0; i < this._dbs.length; i++) {
-      if(this._dbs[i].listeners(event).length > 0) {
-        if(filterDb == null || filterDb.databaseName !== this._dbs[i].databaseName 
-          || filterDb.tag !== this._dbs[i].tag) {
-          this._dbs[i].emit(event, message, object == null ? this._dbs[i] : object);
-          emitted = true;
-        }
+  // Emit the events
+  for(var i = 0; i < this._dbs.length; i++) {
+    if(this._dbs[i].listeners(event).length > 0) {
+      if(filterDb == null || filterDb.databaseName !== this._dbs[i].databaseName 
+        || filterDb.tag !== this._dbs[i].tag) {
+        this._dbs[i].emit(event, message, object == null ? this._dbs[i] : object);
+        emitted = true;
       }
     }
   }
 
+  // Emit error message
+  if(message 
+    && event == 'error' 
+    && !emitted
+    && rethrow_if_no_listeners 
+    && object && object.db) {
+      process.nextTick(function() {
+        object.db.emit(event, message, null);      
+      })
+  }
+
   // Not emitted and we have enabled rethrow, let process.uncaughtException
   // deal with the issue
-  if(!emitted && rethrow_if_no_listeners) throw message;
+  if(!emitted && rethrow_if_no_listeners) {
+    throw message;
+  }
 }
 
 var Base = function Base() {  
@@ -288,6 +288,10 @@ Base.prototype.__executeAllCallbacksWithError = function(err) {
     this._callBackStore.emit(keys[j], err, null);
     // Remove the key
     delete this._callBackStore._notReplied[keys[j]];
+    // Force cleanup _events, node.js seems to set it as a null value
+    if(this._callBackStore._events) {
+      delete this._callBackStore._events[keys[j]];
+    }
   }
 }
 
@@ -311,6 +315,10 @@ Base.prototype.__executeAllServerSpecificErrorCallbacks = function(host, port, e
         this._callBackStore.emit(keys[j], err, null);
         // Remove the key
         delete this._callBackStore._notReplied[keys[j]];
+        // Force cleanup _events, node.js seems to set it as a null value
+        if(this._callBackStore._events) {
+          delete this._callBackStore._events[keys[j]];
+        } 
       }      
     }
   }
@@ -364,10 +372,14 @@ Base.prototype._callHandler = function(id, document, err) {
     var callback = this._callBackStore.listeners(id)[0].listener;
     // Remove the listeners
     this._callBackStore.removeAllListeners(id);
+    // Force key deletion because it nulling it not deleting in 0.10.X
+    if(this._callBackStore._events) {
+      delete this._callBackStore._events[id];
+    }
 
-    // Execute the callback
     try {
-      callback(err, document, info.connection);
+      // Execute the callback if one was provided
+      if(typeof callback == 'function') callback(err, document, info.connection);
     } catch(err) {
       self._emitAcrossAllDbInstances(self, null, "error", err, self, true, true);
     }
@@ -380,7 +392,6 @@ Base.prototype._callHandler = function(id, document, err) {
  * @api private
  */
 Base.prototype._hasHandler = function(id) {
-  // If there is a callback peform it
   return this._callBackStore.listeners(id).length >= 1;
 }
 
@@ -395,7 +406,9 @@ Base.prototype._removeHandler = function(id) {
   // Remove the callback if it's registered
   this._callBackStore.removeAllListeners(id);
   // Force cleanup _events, node.js seems to set it as a null value
-  if(this._callBackStore._events != null) delete this._callBackStore._events[id];
+  if(this._callBackStore._events) {
+    delete this._callBackStore._events[id];
+  }
 }
 
 /**

package/lib/mongodb/connection/repl_set/repl_set.js

@@ -50,7 +50,8 @@ var processor = require('../../utils').processor();
  *  - **sslKey** {Buffer/String, default:null}, String or buffer containing the certificate private key we wish to present (needs to have a mongod server with ssl support, 2.4 or higher)
  *  - **sslPass** {Buffer/String, default:null}, String or buffer containing the certificate password (needs to have a mongod server with ssl support, 2.4 or higher)
  *
- * @class Represents a Replicaset Configuration
+ * @class Represents a 
+ Replicaset Configuration
  * @param {Array} list of server objects participating in the replicaset.
  * @param {Object} [options] additional options for the replicaset connection.
  */
@@ -370,11 +371,27 @@ var locateNewServers = function(self, state, candidateServers, ismaster) {
 var _connectHandler = function(self, candidateServers, instanceServer) {
   return function(err, doc) {
     // If we have an error add to the list
-    if(err) self._state.errors[instanceServer.name] = instanceServer;
+    if(err) {
+      self._state.errors[instanceServer.name] = instanceServer;
+    } else {
+      delete self._state.errors[instanceServer.name];
+    }
 
-    // No error let's analyse the ismaster command
     if(!err) {      
       var ismaster = doc.documents[0]
+
+      // Error the server if 
+      if(!ismaster.ismaster
+        && !ismaster.secondary) {
+        self._state.errors[instanceServer.name] = instanceServer;
+      }
+    }
+
+
+    // No error let's analyse the ismaster command
+    if(!err && self._state.errors[instanceServer.name] == null) {
+      var ismaster = doc.documents[0]
+
       // If no replicaset name exists set the current one
       if(self.options.rs_name == null) {
         self.options.rs_name = ismaster.setName;
@@ -402,9 +419,11 @@ var _connectHandler = function(self, candidateServers, instanceServer) {
         // Get additional new servers that are not currently in set
         var new_servers = locateNewServers(self, self._state, candidateServers, ismaster);
 
-        // If we have new servers join them
-        if(new_servers.length > 0) {
-          candidateServers = candidateServers.concat(new_servers);
+        // Locate any new servers that have not errored out yet
+        for(var i = 0; i < new_servers.length; i++) {
+          if(self._state.errors[new_servers[i].name] == null) {
+            candidateServers.push(new_servers[i])            
+          }
         }
       }
     }
@@ -465,55 +484,14 @@ ReplSet.prototype.checkoutWriter = function() {
   return new Error("no writer connection available");
 }
 
-// var _handler = function(event, self, server) {
-//   return function(err, doc) {
-//     // The event happened to a primary
-//     // Remove it from play
-//     if(self._state.isPrimary(server)) {
-//       var current_master = self._state.master;
-//       self._state.master = null;
-//       self._serverState = ReplSet.REPLSET_READ_ONLY;
-    
-//       if(current_master != null) {
-//         // Unpack variables
-//         var host = current_master.socketOptions.host;
-//         var port = current_master.socketOptions.port;
-
-//         // Fire error on any unknown callbacks
-//         self.__executeAllServerSpecificErrorCallbacks(host, port, err);        
-//       }
-//     } else if(self._state.isSecondary(server)) {
-//       delete self._state.secondaries[server.name];
-//     }
-
-//     // If there is no more connections left and the setting is not destroyed
-//     // set to disconnected
-//     if(Object.keys(self._state.addresses).length == 0 
-//       && self._serverState != ReplSet.REPLSET_DESTROYED) {
-//         self._serverState = ReplSet.REPLSET_DISCONNECTED;
-
-//         // Emit close across all the attached db instances
-//         self._dbStore.emit("close", new Error("replicaset disconnected, no valid servers contactable over tcp"), null, true);
-//     }
-
-//     // Unpack variables
-//     var host = server.socketOptions.host;
-//     var port = server.socketOptions.port;
-
-//     // Fire error on any unknown callbacks
-//     self.__executeAllServerSpecificErrorCallbacks(host, port, err);
-//   }
-// }
-
 ReplSet.prototype.processIsMaster = function(_server, _ismaster) {
   // Server in recovery mode, remove it from available servers
   if(!_ismaster.ismaster && !_ismaster.secondary) {
     // Locate the actual server
-    var server = this.state.addresses[_server.name];
+    var server = this._state.addresses[_server.name];
     // Close the server, simulating the closing of the connection
     // to get right removal semantics
-    if(server)
-      server.close();
+    if(server) server.close();
     // Execute any callback errors
     _handler(null, this, server)(new Error("server is in recovery mode"));
   }

package/lib/mongodb/connection/server.js

@@ -5,6 +5,7 @@ var Connection = require('./connection').Connection,
   ConnectionPool = require('./connection_pool').ConnectionPool,
   EventEmitter = require('events').EventEmitter,
   Base = require('./base').Base,
+  format = require('util').format,
   utils = require('../utils'),
   timers = require('timers'),
   inherits = require('util').inherits;
@@ -73,6 +74,8 @@ function Server(host, port, options) {
   this.sslKey = this.options.sslKey;
   // Password to unlock private key
   this.sslPass = this.options.sslPass;
+  // Set server name
+  this.name = format("%s:%s", host, port);
 
   // Ensure we are not trying to validate with no list of certificates
   if(this.sslValidate && (!Array.isArray(this.sslCA) || this.sslCA.length == 0)) {
@@ -365,8 +368,12 @@ Server.prototype.connect = function(dbInstance, options, callback) {
       // Save document returned so we can query it
       _server.isMasterDoc = reply.documents[0];
       
-      if(self.emitOpen)
+      if(self.emitOpen) {        
         _server._emitAcrossAllDbInstances(_server, eventReceiver, "open", null, returnIsMasterResults ? reply : null, null);        
+        self.emitOpen = false;
+      } else {
+        _server._emitAcrossAllDbInstances(_server, eventReceiver, "reconnect", null, returnIsMasterResults ? reply : null, null);        
+      }
 
       // If we have it set to returnIsMasterResults
       if(returnIsMasterResults) {

package/lib/mongodb/cursor.js

@@ -662,8 +662,6 @@ Cursor.prototype.nextObject = function(options, callback) {
     // If we have no connection set on this cursor check one out
     if(self.connection == null) {
       try {
-        // self.connection = this.read == null ? self.db.serverConfig.checkoutWriter() : self.db.serverConfig.checkoutReader(this.read);
-        // console.log("++++++++++++++++++++++++++++++ checkoutReader :: CURSOR")
         self.connection = self.db.serverConfig.checkoutReader(this.read);
         // Add to the query options
         queryOptions.connection = self.connection;

package/lib/mongodb/db.js

@@ -271,10 +271,22 @@ Db.prototype.open = function(callback) {
       // If we have queued up commands execute a command to trigger replays
       if(self.commands.length > 0) _execute_queued_command(self);
       // Callback
-      return callback(null, self);
+      process.nextTick(function() {
+        try {
+          callback(null, self);
+        } catch(err) {
+          self.close();
+          throw err;
+        }
+      });
     });
   } else {
-    return callback(Error("Server parameter must be of type Server, ReplSet or Mongos"), null);
+    try {
+      callback(Error("Server parameter must be of type Server, ReplSet or Mongos"), null);
+    } catch(err) {
+      self.close();
+      throw err;
+    }
   }
 };
 
@@ -873,6 +885,12 @@ Db.prototype.createCollection = function(collectionName, options, callback) {
   });
 };
 
+var _getReadConcern = function(self, options) {
+  if(options.readPreference) return options.readPreference;
+  if(self.readPreference) return self.readPreference;
+  return 'primary';
+}
+
 /**
  * Execute a command hash against MongoDB. This lets you acess any commands not available through the api on the server.
  *
@@ -915,8 +933,12 @@ Db.prototype.command = function(selector, options, callback) {
     cursor.setReadPreference(readPreference);    
   }
 
-  // Return the next object
-  cursor.nextObject(callback);
+  // Get the next result
+  cursor.nextObject(function(err, result) {
+    if(err) return callback(err, null);
+    if(result == null) return callback(new Error("no result returned from command"), null);
+    callback(null, result);
+  });
 };
 
 /**
@@ -1598,7 +1620,8 @@ Db.prototype._executeQueryCommand = function(db_command, options, callback) {
     }
   }
 
-  if(this.serverConfig.isDestroyed()) return callback(new Error("Connection was destroyed by application"));
+  if(this.serverConfig.isDestroyed()) 
+    return callback(new Error("Connection was destroyed by application"));
 
   // Specific connection
   var connection = options.connection;

package/lib/mongodb/gridfs/gridstore.js

@@ -1151,7 +1151,7 @@ GridStore.unlink = function(db, names, options, callback) {
     var tc = 0;
     for(var i = 0; i < names.length; i++) {
       ++tc;
-      self.unlink(db, names[i], function(result) {
+      self.unlink(db, names[i], options, function(result) {
         if(--tc == 0) {
             callback(null, self);
         }

package/lib/mongodb/mongo_client.js

@@ -151,7 +151,7 @@ MongoClient.connect = function(url, options, callback) {
   callback = typeof args[args.length - 1] == 'function' ? args.pop() : null;
   options = args.length ? args.shift() : null;
   options = options || {};
-  
+
   // Set default empty server options  
   var serverOptions = options.server || {};
   var mongosOptions = options.mongos || {};
@@ -159,7 +159,8 @@ MongoClient.connect = function(url, options, callback) {
   var dbOptions = options.db || {};
 
   // If callback is null throw an exception
-  if(callback == null) throw new Error("no callback function provided");
+  if(callback == null) 
+    throw new Error("no callback function provided");
 
   // Parse the string
   var object = parse(url, options);
@@ -252,8 +253,16 @@ MongoClient.connect = function(url, options, callback) {
 
         if(totalNumberOfServers == 0) {
           // If we have a mix of mongod and mongos, throw an error
-          if(totalNumberOfMongosServers > 0 && totalNumberOfMongodServers > 0)
-            return callback(new Error("cannot combine a list of replicaset seeds and mongos seeds"));
+          if(totalNumberOfMongosServers > 0 && totalNumberOfMongodServers > 0) {
+            return process.nextTick(function() {
+              try {
+                callback(new Error("cannot combine a list of replicaset seeds and mongos seeds"));
+              } catch (err) {
+                if(db) db.close();
+                throw err
+              }              
+            })
+          }
           
           if(totalNumberOfMongodServers == 0 && object.servers.length == 1) {
             var obj = object.servers[0];
@@ -278,7 +287,16 @@ MongoClient.connect = function(url, options, callback) {
             }
           }
 
-          if(serverConfig == null) return callback(new Error("Could not locate any valid servers in initial seed list"));
+          if(serverConfig == null) {
+            return process.nextTick(function() {
+              try {
+                callback(new Error("Could not locate any valid servers in initial seed list"));
+              } catch (err) {
+                if(db) db.close();
+                throw err
+              }
+            });
+          }
           // Ensure no firing off open event before we are ready
           serverConfig.emitOpen = false;
           // Set up all options etc and connect to the database
@@ -332,7 +350,16 @@ var _finishConnecting = function(serverConfig, object, options, callback) {
   var db = new Db(object.dbName, serverConfig, object.db_options);
   // Open the db
   db.open(function(err, db){
-    if(err) return callback(err, null);
+    if(err) {
+      return process.nextTick(function() {
+        try {
+          callback(err, null);
+        } catch (err) {
+          if(db) db.close();
+          throw err
+        }
+      });
+    }
 
     if(db.options !== null && !db.options.safe && !db.options.journal 
       && !db.options.w && !db.options.fsync && typeof db.options.w != 'number'
@@ -355,14 +382,35 @@ var _finishConnecting = function(serverConfig, object, options, callback) {
       // Authenticate
       authentication_db.authenticate(object.auth.user, object.auth.password, options, function(err, success){
         if(success){
-          callback(null, db);
+          process.nextTick(function() {
+            try {
+              callback(null, db);            
+            } catch (err) {
+              if(db) db.close();
+              throw err
+            }
+          });
         } else {
           if(db) db.close();
-          callback(err ? err : new Error('Could not authenticate user ' + auth[0]), null);
+          process.nextTick(function() {
+            try {
+              callback(err ? err : new Error('Could not authenticate user ' + auth[0]), null);
+            } catch (err) {
+              if(db) db.close();
+              throw err
+            }
+          });
         }
       });
     } else {
-      callback(err, db);
+      process.nextTick(function() {
+        try {
+          callback(err, db);            
+        } catch (err) {
+          if(db) db.close();
+          throw err
+        }
+      })
     }
   });
 }

package/lib/mongodb/responses/mongo_reply.js

@@ -42,99 +42,32 @@ MongoReply.prototype.parseHeader = function(binary_reply, bson) {
 
 MongoReply.prototype.parseBody = function(binary_reply, bson, raw, callback) {
   raw = raw == null ? false : raw;
-  // Just set a doc limit for deserializing
-  var docLimitSize = 1024*20;
 
-  // If our message length is very long, let's switch to process.nextTick for messages
-  if(this.messageLength > docLimitSize) {
-    var batchSize = this.numberReturned;
-    this.documents = new Array(this.numberReturned);
-
-    // Just walk down until we get a positive number >= 1
-    for(var i = 50; i > 0; i--) {
-      if((this.numberReturned/i) >= 1) {
-        batchSize = i;
-        break;
+  try {
+    // Let's unpack all the bson documents, deserialize them and store them
+    for(var object_index = 0; object_index < this.numberReturned; object_index++) {
+      var _options = {promoteLongs: bson.promoteLongs};
+      
+      // Read the size of the bson object
+      var bsonObjectSize = binary_reply[this.index] | binary_reply[this.index + 1] << 8 | binary_reply[this.index + 2] << 16 | binary_reply[this.index + 3] << 24;
+      
+      // If we are storing the raw responses to pipe straight through
+      if(raw) {
+        // Deserialize the object and add to the documents array
+        this.documents.push(binary_reply.slice(this.index, this.index + bsonObjectSize));
+      } else {
+        // Deserialize the object and add to the documents array
+        this.documents.push(bson.deserialize(binary_reply.slice(this.index, this.index + bsonObjectSize), _options));
       }
+      
+      // Adjust binary index to point to next block of binary bson data
+      this.index = this.index + bsonObjectSize;
     }
-
-    // Actual main creator of the processFunction setting internal state to control the flow
-    var parseFunction = function(_self, _binary_reply, _batchSize, _numberReturned) {
-      var object_index = 0;
-      // Internal loop process that will use nextTick to ensure we yield some time
-      var processFunction = function() {
-        // Adjust batchSize if we have less results left than batchsize
-        if((_numberReturned - object_index) < _batchSize) {
-          _batchSize = _numberReturned - object_index;
-        }
-
-        // If raw just process the entries
-        if(raw) {
-          // Iterate over the batch
-          for(var i = 0; i < _batchSize; i++) {
-            // Are we done ?
-            if(object_index <= _numberReturned) {
-              // Read the size of the bson object
-              var bsonObjectSize = _binary_reply[_self.index] | _binary_reply[_self.index + 1] << 8 | _binary_reply[_self.index + 2] << 16 | _binary_reply[_self.index + 3] << 24;
-              // If we are storing the raw responses to pipe straight through
-              _self.documents[object_index] = binary_reply.slice(_self.index, _self.index + bsonObjectSize);
-              // Adjust binary index to point to next block of binary bson data
-              _self.index = _self.index + bsonObjectSize;
-              // Update number of docs parsed
-              object_index = object_index + 1;
-            }
-          }
-        } else {
-          try {
-            // Parse documents
-            _self.index = bson.deserializeStream(binary_reply
-                , _self.index
-                , _batchSize
-                , _self.documents
-                , object_index
-                , {promoteLongs: bson.promoteLongs});
-            // Adjust index
-            object_index = object_index + _batchSize;
-          } catch (err) {
-            return callback(err);
-          }
-        }
-
-        // If we have more documents process NextTick
-        if(object_index < _numberReturned) {
-          processor(processFunction);
-        } else {
-          callback(null);
-        }
-      }
-
-      // Return the process function
-      return processFunction;
-    }(this, binary_reply, batchSize, this.numberReturned)();
-  } else {
-    try {
-      // Let's unpack all the bson documents, deserialize them and store them
-      for(var object_index = 0; object_index < this.numberReturned; object_index++) {
-        var _options = {promoteLongs: bson.promoteLongs};
-        // Read the size of the bson object
-        var bsonObjectSize = binary_reply[this.index] | binary_reply[this.index + 1] << 8 | binary_reply[this.index + 2] << 16 | binary_reply[this.index + 3] << 24;
-        // If we are storing the raw responses to pipe straight through
-        if(raw) {
-          // Deserialize the object and add to the documents array
-          this.documents.push(binary_reply.slice(this.index, this.index + bsonObjectSize));
-        } else {
-          // Deserialize the object and add to the documents array
-          this.documents.push(bson.deserialize(binary_reply.slice(this.index, this.index + bsonObjectSize), _options));
-        }
-        // Adjust binary index to point to next block of binary bson data
-        this.index = this.index + bsonObjectSize;
-      }
-    } catch(err) {
-      return callback(err);
-    }
-
+    
     // No error return
     callback(null);
+  } catch(err) {
+    return callback(err);
   }
 }
 

package/package.json

@@ -1,7 +1,7 @@
 { "name" :            "mongodb"
 , "description" :     "A node.js driver for MongoDB"
 , "keywords" :        ["mongodb", "mongo", "driver", "db"]
-, "version" :         "1.3.14"
+, "version" :         "1.3.19"
 , "author" :          "Christian Amor Kvalheim <christkv@gmail.com>"
 , "contributors" :  [ "Aaron Heckmann",
                       "Christoph Pojer",

package/t.js

@@ -0,0 +1,147 @@
+var mongodb = require('./lib/mongodb');                                               
+
+var mongoserver = new mongodb.Server('localhost', 27017, {});                   
+var db_conn = new mongodb.Db('test1', mongoserver, { w : 1 });                  
+
+db_conn.on('open', function () {                                                
+  console.log("this is an open event");                                         
+});                                                                             
+
+db_conn.on('close', function () {                                               
+  console.log("this is a close event");                                         
+});                                                                             
+
+db_conn.on('reconnect', function () {
+  console.log("this is a reconnect event");                                         
+});                                                                             
+
+db_conn.open(function (err) {                                                   
+  if (err) throw err;                                                           
+
+  var col = db_conn.collection('test');                                         
+
+  var count = 0;                                                                
+  // Run a simple 'find' query every second                                     
+  setInterval(function() {                                                      
+    col.findOne(function(err, item) {  
+      if (err) {                                                                
+        return console.log("mongodb query not ok %d", count)                    
+      }                                                                         
+      console.log("mongodb query ok %d", count);                                
+      count++;                                                                  
+    })                                                                          
+    if (count == 40) {                                                          
+      db_conn.close();                                                          
+    }                                                                           
+  }, 1000)                                                                      
+  console.log('hi');                                                            
+});
+
+// var MongoClient = require('./lib/mongodb').MongoClient
+// 	, Server = require('./lib/mongodb').Server
+//   , ReplSet = require('./lib/mongodb').ReplSet
+// 	, Db = require('./lib/mongodb').Db;
+// var format = require('util').format;
+
+// var host = process.env['MONGO_NODE_DRIVER_HOST'] || 'localhost'; 
+// var port = process.env['MONGO_NODE_DRIVER_PORT'] || 27017;
+// var url = format("mongodb://%s:%s,%s:%s,%s:%s/node-mongo-examples"
+//         , host, port, host, 27018, host, 27019);
+// var url = "mongodb://localhost:27017/node-mongo-examples"
+// // console.dir(url)
+
+// // MongoClient.connect(url, function(err, db) {
+// // new Db("node-mongo-examples", new Server("localhost", 27017), {w:1}).open(function(err, db) {
+// var replSet = new ReplSet([new Server("localhost", 31000)
+//   , new Server("localhost", 31001)
+//   , new Server("localhost", 31002)])
+// new Db("node-mongo-examples", replSet, {safe:true}).open(function(err, db) {
+//   if(err) throw err;
+//   console.log("=========================== 0")
+//   db.close();
+// });
+
+//   // console.log("------------------------- 0")
+
+//   // db.on('error', function(err, db) {
+//   //  console.log("---------------------- GOT ERROR")
+//   //  console.dir(err)
+//   //   db.close(function() {
+//   //    console.log("----------------- error")
+//   //     process.exit(1);
+//   //   })
+//   // });
+//    //  // throw new Error("3")
+
+//   // console.log('connected');
+
+//   // db.collection('t').findOne(function(err, result) {
+//   //  console.log("33333")
+//    //  throw new Error("3")
+//   // })
+    
+//   // thisMethodDoesNotExists('foo', 'bar', 123);
+
+// process.on("uncaughtException", function(err) {
+// 	console.log("######################")
+// })
+
+// // var now;
+// // var obj, i;
+// // var count = 10000000;
+// // var key = 'key';
+ 
+// // obj = {};
+// // now = Date.now();
+// // for (i = 0; i < count; i++) {
+// // obj[key] = 1;
+// // obj[key] = null;
+// // }
+// // console.log('null assignment(`obj[key] = null`):\n %d ms', Date.now() - now);
+ 
+// // obj = {};
+// // now = Date.now();
+// // for (i = 0; i < count; i++) {
+// // obj[key] = 1;
+// // delete obj[key];
+// // }
+// // console.log('deleting property(`delete obj[key]`):\n %d ms', Date.now() - now);
+
+// // // var mongodb = require('./lib/mongodb');
+
+// // // // var url = 'mongodb://user:pass@host1,host2,host3/db';
+// // // var url = 'mongodb://127.0.0.1:31000,192.168.2.173:31001,127.0.0.1:31002/test';
+// // // var options = {db: {safe: true}, server: {auto_reconnect: true}};
+
+// // // mongodb.connect(url, options, function (err, db) {
+// // //   if (err) {
+// // //     console.log(err);
+// // //     process.exit(1);
+// // //   }
+
+// // //   db.collection('test', function (err, c) {
+// // //     if (err) {
+// // //       console.log(err);
+// // //       process.exit(2);
+// // //     }
+
+// // //     var successCount = 0;
+// // //     var errCount = 0;
+// // //     var lastErr = null;
+// // //     setInterval(function () {
+// // //       c.find({}).limit(100).toArray(function (err, results) {
+// // //         if (err) {
+// // //           lastErr = err;
+// // //           errCount++;
+// // //         } else {
+// // //           successCount++;
+// // //         }
+// // //       });
+// // //     }, 100);
+
+// // //     setInterval(function () {
+// // //       console.log("STATUS", successCount, errCount);
+// // //     }, 1000);
+
+// // //   });
+// // // });

package/install.js

@@ -1,40 +0,0 @@
-var spawn = require('child_process').spawn,
-  exec = require('child_process').exec;
-
-process.stdout.write("================================================================================\n");
-process.stdout.write("=                                                                              =\n");
-process.stdout.write("=  To install with C++ bson parser do <npm install mongodb --mongodb:native>   =\n");
-process.stdout.write("=                                                                              =\n");
-process.stdout.write("================================================================================\n");
-
-// Check if we want to build the native code
-var build_native = process.env['npm_package_config_native'] != null ? process.env['npm_package_config_native'] : 'false';
-build_native = build_native == 'true' ? true : false;
-// If we are building the native bson extension ensure we use gmake if available
-if(build_native) {
-  // Check if we need to use gmake
-  exec('which gmake', function(err, stdout, stderr) {
-    // Set up spawn command
-    var make = null;
-    // No gmake build using make
-    if(err != null) {
-      make = spawn('make', ['total']);
-    } else {
-      make = spawn('gmake', ['total']);
-    }
-
-    // Execute spawn
-    make.stdout.on('data', function(data) {
-      process.stdout.write(data);
-    })
-
-    make.stderr.on('data', function(data) {
-      process.stdout.write(data);
-    })
-
-    make.on('exit', function(code) {
-      process.stdout.write('child process exited with code ' + code + "\n");
-    })
-  });  
-}
-