You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@couchdb.apache.org by ga...@apache.org on 2015/11/30 10:37:11 UTC
[29/51] [abbrv] [partial] couchdb-nmo git commit: Remove node_modules
from repo
http://git-wip-us.apache.org/repos/asf/couchdb-nmo/blob/6436833c/node_modules/couchbulkimporter/node_modules/mongodb/node_modules/mongodb-core/lib/cursor.js
----------------------------------------------------------------------
diff --git a/node_modules/couchbulkimporter/node_modules/mongodb/node_modules/mongodb-core/lib/cursor.js b/node_modules/couchbulkimporter/node_modules/mongodb/node_modules/mongodb-core/lib/cursor.js
deleted file mode 100644
index ab82818..0000000
--- a/node_modules/couchbulkimporter/node_modules/mongodb/node_modules/mongodb-core/lib/cursor.js
+++ /dev/null
@@ -1,756 +0,0 @@
-"use strict";
-
-var Long = require('bson').Long
- , Logger = require('./connection/logger')
- , MongoError = require('./error')
- , f = require('util').format;
-
-/**
- * This is a cursor results callback
- *
- * @callback resultCallback
- * @param {error} error An error object. Set to null if no error present
- * @param {object} document
- */
-
-/**
- * @fileOverview The **Cursor** class is an internal class that embodies a cursor on MongoDB
- * allowing for iteration over the results returned from the underlying query.
- *
- * **CURSORS Cannot directly be instantiated**
- * @example
- * var Server = require('mongodb-core').Server
- * , ReadPreference = require('mongodb-core').ReadPreference
- * , assert = require('assert');
- *
- * var server = new Server({host: 'localhost', port: 27017});
- * // Wait for the connection event
- * server.on('connect', function(server) {
- * assert.equal(null, err);
- *
- * // Execute the write
- * var cursor = _server.cursor('integration_tests.inserts_example4', {
- * find: 'integration_tests.example4'
- * , query: {a:1}
- * }, {
- * readPreference: new ReadPreference('secondary');
- * });
- *
- * // Get the first document
- * cursor.next(function(err, doc) {
- * assert.equal(null, err);
- * server.destroy();
- * });
- * });
- *
- * // Start connecting
- * server.connect();
- */
-
-/**
- * Creates a new Cursor, not to be used directly
- * @class
- * @param {object} bson An instance of the BSON parser
- * @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
- * @param {{object}|Long} cmd The selector (can be a command or a cursorId)
- * @param {object} [options=null] Optional settings.
- * @param {object} [options.batchSize=1000] Batchsize for the operation
- * @param {array} [options.documents=[]] Initial documents list for cursor
- * @param {object} [options.transforms=null] Transform methods for the cursor results
- * @param {function} [options.transforms.query] Transform the value returned from the initial query
- * @param {function} [options.transforms.doc] Transform each document returned from Cursor.prototype.next
- * @param {object} topology The server topology instance.
- * @param {object} topologyOptions The server topology options.
- * @return {Cursor} A cursor instance
- * @property {number} cursorBatchSize The current cursorBatchSize for the cursor
- * @property {number} cursorLimit The current cursorLimit for the cursor
- * @property {number} cursorSkip The current cursorSkip for the cursor
- */
-var Cursor = function(bson, ns, cmd, options, topology, topologyOptions) {
- options = options || {};
- // Cursor reference
- var self = this;
- // Initial query
- var query = null;
-
- // Cursor connection
- this.connection = null;
- // Cursor server
- this.server = null;
-
- // Do we have a not connected handler
- this.disconnectHandler = options.disconnectHandler;
-
- // Set local values
- this.bson = bson;
- this.ns = ns;
- this.cmd = cmd;
- this.options = options;
- this.topology = topology;
-
- // All internal state
- this.cursorState = {
- cursorId: null
- , cmd: cmd
- , documents: options.documents || []
- , cursorIndex: 0
- , dead: false
- , killed: false
- , init: false
- , notified: false
- , limit: options.limit || cmd.limit || 0
- , skip: options.skip || cmd.skip || 0
- , batchSize: options.batchSize || cmd.batchSize || 1000
- , currentLimit: 0
- // Result field name if not a cursor (contains the array of results)
- , transforms: options.transforms
- }
-
- // Callback controller
- this.callbacks = null;
-
- // Logger
- this.logger = Logger('Cursor', options);
-
- //
- // Did we pass in a cursor id
- if(typeof cmd == 'number') {
- this.cursorState.cursorId = Long.fromNumber(cmd);
- } else if(cmd instanceof Long) {
- this.cursorState.cursorId = cmd;
- }
-}
-
-Cursor.prototype.setCursorBatchSize = function(value) {
- this.cursorState.batchSize = value;
-}
-
-Cursor.prototype.cursorBatchSize = function() {
- return this.cursorState.batchSize;
-}
-
-Cursor.prototype.setCursorLimit = function(value) {
- this.cursorState.limit = value;
-}
-
-Cursor.prototype.cursorLimit = function() {
- return this.cursorState.limit;
-}
-
-Cursor.prototype.setCursorSkip = function(value) {
- this.cursorState.skip = value;
-}
-
-Cursor.prototype.cursorSkip = function() {
- return this.cursorState.skip;
-}
-
-// //
-// // Execute getMore command
-// var execGetMore = function(self, callback) {
-// }
-
-//
-// Execute the first query
-var execInitialQuery = function(self, query, cmd, options, cursorState, connection, logger, callbacks, callback) {
- if(logger.isDebug()) {
- logger.debug(f("issue initial query [%s] with flags [%s]"
- , JSON.stringify(cmd)
- , JSON.stringify(query)));
- }
-
- var queryCallback = function(err, result) {
- if(err) return callback(err);
-
- if(result.queryFailure) {
- return callback(MongoError.create(result.documents[0]), null);
- }
-
- // Check if we have a command cursor
- if(Array.isArray(result.documents) && result.documents.length == 1
- && (!cmd.find || (cmd.find && cmd.virtual == false))
- && (result.documents[0].cursor != 'string'
- || result.documents[0]['$err']
- || result.documents[0]['errmsg']
- || Array.isArray(result.documents[0].result))
- ) {
-
- // We have a an error document return the error
- if(result.documents[0]['$err']
- || result.documents[0]['errmsg']) {
- return callback(MongoError.create(result.documents[0]), null);
- }
-
- // We have a cursor document
- if(result.documents[0].cursor != null
- && typeof result.documents[0].cursor != 'string') {
- var id = result.documents[0].cursor.id;
- // If we have a namespace change set the new namespace for getmores
- if(result.documents[0].cursor.ns) {
- self.ns = result.documents[0].cursor.ns;
- }
- // Promote id to long if needed
- cursorState.cursorId = typeof id == 'number' ? Long.fromNumber(id) : id;
- // If we have a firstBatch set it
- if(Array.isArray(result.documents[0].cursor.firstBatch)) {
- cursorState.documents = result.documents[0].cursor.firstBatch;//.reverse();
- }
-
- // Return after processing command cursor
- return callback(null, null);
- }
-
- if(Array.isArray(result.documents[0].result)) {
- cursorState.documents = result.documents[0].result;
- cursorState.cursorId = Long.ZERO;
- return callback(null, null);
- }
- }
-
- // Otherwise fall back to regular find path
- cursorState.cursorId = result.cursorId;
- cursorState.documents = result.documents;
-
- // Transform the results with passed in transformation method if provided
- if(cursorState.transforms && typeof cursorState.transforms.query == 'function') {
- cursorState.documents = cursorState.transforms.query(result);
- }
-
- // Return callback
- callback(null, null);
- }
-
- // If we have a raw query decorate the function
- if(options.raw || cmd.raw) {
- queryCallback.raw = options.raw || cmd.raw;
- }
-
- // Do we have documentsReturnedIn set on the query
- if(typeof query.documentsReturnedIn == 'string') {
- queryCallback.documentsReturnedIn = query.documentsReturnedIn;
- }
-
- // Set up callback
- callbacks.register(query.requestId, queryCallback);
-
- // Write the initial command out
- connection.write(query.toBin());
-}
-
-//
-// Handle callback (including any exceptions thrown)
-var handleCallback = function(callback, err, result) {
- try {
- callback(err, result);
- } catch(err) {
- process.nextTick(function() {
- throw err;
- });
- }
-}
-
-
-// Internal methods
-Cursor.prototype._find = function(callback) {
- var self = this;
- // execInitialQuery(self, self.query, self.cmd, self.options, self.cursorState, self.connection, self.logger, self.callbacks, function(err, r) {
- if(self.logger.isDebug()) {
- self.logger.debug(f("issue initial query [%s] with flags [%s]"
- , JSON.stringify(self.cmd)
- , JSON.stringify(self.query)));
- }
-
- var queryCallback = function(err, result) {
- if(err) return callback(err);
-
- if(result.queryFailure) {
- return callback(MongoError.create(result.documents[0]), null);
- }
-
- // Check if we have a command cursor
- if(Array.isArray(result.documents) && result.documents.length == 1
- && (!self.cmd.find || (self.cmd.find && self.cmd.virtual == false))
- && (result.documents[0].cursor != 'string'
- || result.documents[0]['$err']
- || result.documents[0]['errmsg']
- || Array.isArray(result.documents[0].result))
- ) {
-
- // We have a an error document return the error
- if(result.documents[0]['$err']
- || result.documents[0]['errmsg']) {
- return callback(MongoError.create(result.documents[0]), null);
- }
-
- // We have a cursor document
- if(result.documents[0].cursor != null
- && typeof result.documents[0].cursor != 'string') {
- var id = result.documents[0].cursor.id;
- // If we have a namespace change set the new namespace for getmores
- if(result.documents[0].cursor.ns) {
- self.ns = result.documents[0].cursor.ns;
- }
- // Promote id to long if needed
- self.cursorState.cursorId = typeof id == 'number' ? Long.fromNumber(id) : id;
- // If we have a firstBatch set it
- if(Array.isArray(result.documents[0].cursor.firstBatch)) {
- self.cursorState.documents = result.documents[0].cursor.firstBatch;//.reverse();
- }
-
- // Return after processing command cursor
- return callback(null, null);
- }
-
- if(Array.isArray(result.documents[0].result)) {
- self.cursorState.documents = result.documents[0].result;
- self.cursorState.cursorId = Long.ZERO;
- return callback(null, null);
- }
- }
-
- // Otherwise fall back to regular find path
- self.cursorState.cursorId = result.cursorId;
- self.cursorState.documents = result.documents;
-
- // Transform the results with passed in transformation method if provided
- if(self.cursorState.transforms && typeof self.cursorState.transforms.query == 'function') {
- self.cursorState.documents = self.cursorState.transforms.query(result);
- }
-
- // Return callback
- callback(null, null);
- }
- // console.log("------------------------- 2")
-
- // If we have a raw query decorate the function
- if(self.options.raw || self.cmd.raw) {
- queryCallback.raw = self.options.raw || self.cmd.raw;
- }
- // console.log("------------------------- 3")
-
- // Do we have documentsReturnedIn set on the query
- if(typeof self.query.documentsReturnedIn == 'string') {
- queryCallback.documentsReturnedIn = self.query.documentsReturnedIn;
- }
- // console.log("------------------------- 4")
-
- // Set up callback
- self.callbacks.register(self.query.requestId, queryCallback);
-
- // Write the initial command out
- self.connection.write(self.query.toBin());
-// console.log("------------------------- 5")
-}
-
-Cursor.prototype._getmore = function(callback) {
- if(this.logger.isDebug()) this.logger.debug(f("schedule getMore call for query [%s]", JSON.stringify(this.query)))
- // Determine if it's a raw query
- var raw = this.options.raw || this.cmd.raw;
- // We have a wire protocol handler
- this.server.wireProtocolHandler.getMore(this.bson, this.ns, this.cursorState, this.cursorState.batchSize, raw, this.connection, this.callbacks, this.options, callback);
-}
-
-Cursor.prototype._killcursor = function(callback) {
- // Set cursor to dead
- this.cursorState.dead = true;
- this.cursorState.killed = true;
- // Remove documents
- this.cursorState.documents = [];
-
- // If no cursor id just return
- if(this.cursorState.cursorId == null || this.cursorState.cursorId.isZero() || this.cursorState.init == false) {
- if(callback) callback(null, null);
- return;
- }
-
- // Execute command
- this.server.wireProtocolHandler.killCursor(this.bson, this.ns, this.cursorState.cursorId, this.connection, this.callbacks, callback);
-}
-
-/**
- * Clone the cursor
- * @method
- * @return {Cursor}
- */
-Cursor.prototype.clone = function() {
- return this.topology.cursor(this.ns, this.cmd, this.options);
-}
-
-/**
- * Checks if the cursor is dead
- * @method
- * @return {boolean} A boolean signifying if the cursor is dead or not
- */
-Cursor.prototype.isDead = function() {
- return this.cursorState.dead == true;
-}
-
-/**
- * Checks if the cursor was killed by the application
- * @method
- * @return {boolean} A boolean signifying if the cursor was killed by the application
- */
-Cursor.prototype.isKilled = function() {
- return this.cursorState.killed == true;
-}
-
-/**
- * Checks if the cursor notified it's caller about it's death
- * @method
- * @return {boolean} A boolean signifying if the cursor notified the callback
- */
-Cursor.prototype.isNotified = function() {
- return this.cursorState.notified == true;
-}
-
-/**
- * Returns current buffered documents length
- * @method
- * @return {number} The number of items in the buffered documents
- */
-Cursor.prototype.bufferedCount = function() {
- return this.cursorState.documents.length - this.cursorState.cursorIndex;
-}
-
-/**
- * Returns current buffered documents
- * @method
- * @return {Array} An array of buffered documents
- */
-Cursor.prototype.readBufferedDocuments = function(number) {
- var unreadDocumentsLength = this.cursorState.documents.length - this.cursorState.cursorIndex;
- var length = number < unreadDocumentsLength ? number : unreadDocumentsLength;
- var elements = this.cursorState.documents.slice(this.cursorState.cursorIndex, this.cursorState.cursorIndex + length);
-
- // Transform the doc with passed in transformation method if provided
- if(this.cursorState.transforms && typeof this.cursorState.transforms.doc == 'function') {
- // Transform all the elements
- for(var i = 0; i < elements.length; i++) {
- elements[i] = this.cursorState.transforms.doc(elements[i]);
- }
- }
-
- // Ensure we do not return any more documents than the limit imposed
- // Just return the number of elements up to the limit
- if(this.cursorState.limit > 0 && (this.cursorState.currentLimit + elements.length) > this.cursorState.limit) {
- elements = elements.slice(0, (this.cursorState.limit - this.cursorState.currentLimit));
- this.kill();
- }
-
- // Adjust current limit
- this.cursorState.currentLimit = this.cursorState.currentLimit + elements.length;
- this.cursorState.cursorIndex = this.cursorState.cursorIndex + elements.length;
-
- // Return elements
- return elements;
-}
-
-/**
- * Kill the cursor
- * @method
- * @param {resultCallback} callback A callback function
- */
-Cursor.prototype.kill = function(callback) {
- this._killcursor(callback);
-}
-
-/**
- * Resets the cursor
- * @method
- * @return {null}
- */
-Cursor.prototype.rewind = function() {
- if(this.cursorState.init) {
- if(!this.cursorState.dead) {
- this.kill();
- }
-
- this.cursorState.currentLimit = 0;
- this.cursorState.init = false;
- this.cursorState.dead = false;
- this.cursorState.killed = false;
- this.cursorState.notified = false;
- this.cursorState.documents = [];
- this.cursorState.cursorId = null;
- this.cursorState.cursorIndex = 0;
- }
-}
-
-/**
- * Validate if the connection is dead and return error
- */
-var isConnectionDead = function(self, callback) {
- if(self.connection
- && !self.connection.isConnected()) {
- self.cursorState.notified = true;
- self.cursorState.killed = true;
- self.cursorState.documents = [];
- self.cursorState.cursorIndex = 0;
- callback(MongoError.create(f('connection to host %s:%s was destroyed', self.connection.host, self.connection.port)))
- return true;
- }
-
- return false;
-}
-
-/**
- * Validate if the cursor is dead but was not explicitly killed by user
- */
-var isCursorDeadButNotkilled = function(self, callback) {
- // Cursor is dead but not marked killed, return null
- if(self.cursorState.dead && !self.cursorState.killed) {
- self.cursorState.notified = true;
- self.cursorState.killed = true;
- self.cursorState.documents = [];
- self.cursorState.cursorIndex = 0;
- handleCallback(callback, null, null);
- return true;
- }
-
- return false;
-}
-
-/**
- * Validate if the cursor is dead and was killed by user
- */
-var isCursorDeadAndKilled = function(self, callback) {
- if(self.cursorState.dead && self.cursorState.killed) {
- handleCallback(callback, MongoError.create("cursor is dead"));
- return true;
- }
-
- return false;
-}
-
-/**
- * Validate if the cursor was killed by the user
- */
-var isCursorKilled = function(self, callback) {
- if(self.cursorState.killed) {
- self.cursorState.notified = true;
- self.cursorState.documents = [];
- self.cursorState.cursorIndex = 0;
- handleCallback(callback, null, null);
- return true;
- }
-
- return false;
-}
-
-/**
- * Mark cursor as being dead and notified
- */
-var setCursorDeadAndNotified = function(self, callback) {
- self.cursorState.dead = true;
- self.cursorState.notified = true;
- self.cursorState.documents = [];
- self.cursorState.cursorIndex = 0;
- handleCallback(callback, null, null);
-}
-
-/**
- * Mark cursor as being notified
- */
-var setCursorNotified = function(self, callback) {
- self.cursorState.notified = true;
- self.cursorState.documents = [];
- self.cursorState.cursorIndex = 0;
- handleCallback(callback, null, null);
-}
-
-var nextFunction = function(self, callback) {
- // We have notified about it
- if(self.cursorState.notified) {
- return callback(new Error('cursor is exhausted'));
- }
-
- // Cursor is killed return null
- if(isCursorKilled(self, callback)) return;
-
- // Cursor is dead but not marked killed, return null
- if(isCursorDeadButNotkilled(self, callback)) return;
-
- // We have a dead and killed cursor, attempting to call next should error
- if(isCursorDeadAndKilled(self, callback)) return;
-
- // We have just started the cursor
- if(!self.cursorState.init) {
- // Topology is not connected, save the call in the provided store to be
- // Executed at some point when the handler deems it's reconnected
- if(!self.topology.isConnected(self.options) && self.disconnectHandler != null) {
- return self.disconnectHandler.addObjectAndMethod('cursor', self, 'next', [callback], callback);
- }
-
- try {
- // Get a server
- self.server = self.topology.getServer(self.options);
- // Get a connection
- self.connection = self.server.getConnection();
- // Get the callbacks
- self.callbacks = self.server.getCallbacks();
- } catch(err) {
- return callback(err);
- }
-
- // Set as init
- self.cursorState.init = true;
-
- try {
- // Get the right wire protocol command
- self.query = self.server.wireProtocolHandler.command(self.bson, self.ns, self.cmd, self.cursorState, self.topology, self.options);
- } catch(err) {
- return callback(err);
- }
- }
-
- // Process exhaust messages
- var processExhaustMessages = function(err, result) {
- if(err) {
- self.cursorState.dead = true;
- self.callbacks.unregister(self.query.requestId);
- return callback(err);
- }
-
- // Concatenate all the documents
- self.cursorState.documents = self.cursorState.documents.concat(result.documents);
-
- // If we have no documents left
- if(Long.ZERO.equals(result.cursorId)) {
- self.cursorState.cursorId = Long.ZERO;
- self.callbacks.unregister(self.query.requestId);
- return nextFunction(self, callback);
- }
-
- // Set up next listener
- self.callbacks.register(result.requestId, processExhaustMessages)
-
- // Initial result
- if(self.cursorState.cursorId == null) {
- self.cursorState.cursorId = result.cursorId;
- nextFunction(self, callback);
- }
- }
-
- // If we have exhaust
- if(self.cmd.exhaust && self.cursorState.cursorId == null) {
- // Handle all the exhaust responses
- self.callbacks.register(self.query.requestId, processExhaustMessages);
- // Write the initial command out
- return self.connection.write(self.query.toBin());
- } else if(self.cmd.exhaust && self.cursorState.cursorIndex < self.cursorState.documents.length) {
- return handleCallback(callback, null, self.cursorState.documents[self.cursorState.cursorIndex++]);
- } else if(self.cmd.exhaust && Long.ZERO.equals(self.cursorState.cursorId)) {
- self.callbacks.unregister(self.query.requestId);
- return setCursorNotified(self, callback);
- } else if(self.cmd.exhaust) {
- return setTimeout(function() {
- if(Long.ZERO.equals(self.cursorState.cursorId)) return;
- nextFunction(self, callback);
- }, 1);
- }
-
- // If we don't have a cursorId execute the first query
- if(self.cursorState.cursorId == null) {
- // Check if connection is dead and return if not possible to
- // execute the query against the db
- if(isConnectionDead(self, callback)) return;
-
- // Check if topology is destroyed
- if(self.topology.isDestroyed()) return callback(new MongoError(f('connection destroyed, not possible to instantiate cursor')));
-
- // query, cmd, options, cursorState, callback
- self._find(function(err, r) {
- if(err) return handleCallback(callback, err, null);
- if(self.cursorState.documents.length == 0 && !self.cmd.tailable && !self.cmd.awaitData) {
- return setCursorNotified(self, callback);
- }
-
- nextFunction(self, callback);
- });
- } else if(self.cursorState.limit > 0 && self.cursorState.currentLimit >= self.cursorState.limit) {
- // Ensure we kill the cursor on the server
- self.kill();
- // Set cursor in dead and notified state
- return setCursorDeadAndNotified(self, callback);
- } else if(self.cursorState.cursorIndex == self.cursorState.documents.length
- && !Long.ZERO.equals(self.cursorState.cursorId)) {
- // Ensure an empty cursor state
- self.cursorState.documents = [];
- self.cursorState.cursorIndex = 0;
-
- // Check if topology is destroyed
- if(self.topology.isDestroyed()) return callback(new MongoError(f('connection destroyed, not possible to instantiate cursor')));
-
- // Check if connection is dead and return if not possible to
- // execute a getmore on this connection
- if(isConnectionDead(self, callback)) return;
-
- // Execute the next get more
- self._getmore(function(err, doc) {
- if(err) return handleCallback(callback, err);
- if(self.cursorState.documents.length == 0
- && Long.ZERO.equals(self.cursorState.cursorId)) {
- self.cursorState.dead = true;
- }
-
- // Tailable cursor getMore result, notify owner about it
- // No attempt is made here to retry, this is left to the user of the
- // core module to handle to keep core simple
- if(self.cursorState.documents.length == 0 && self.cmd.tailable) {
- return handleCallback(callback, MongoError.create({
- message: "No more documents in tailed cursor"
- , tailable: self.cmd.tailable
- , awaitData: self.cmd.awaitData
- }));
- }
-
- if(self.cursorState.limit > 0 && self.cursorState.currentLimit >= self.cursorState.limit) {
- return setCursorDeadAndNotified(self, callback);
- }
-
- nextFunction(self, callback);
- });
- } else if(self.cursorState.documents.length == self.cursorState.cursorIndex
- && self.cmd.tailable) {
- return handleCallback(callback, MongoError.create({
- message: "No more documents in tailed cursor"
- , tailable: self.cmd.tailable
- , awaitData: self.cmd.awaitData
- }));
- } else if(self.cursorState.documents.length == self.cursorState.cursorIndex
- && Long.ZERO.equals(self.cursorState.cursorId)) {
- setCursorDeadAndNotified(self, callback);
- } else {
- if(self.cursorState.limit > 0 && self.cursorState.currentLimit >= self.cursorState.limit) {
- // Ensure we kill the cursor on the server
- self.kill();
- // Set cursor in dead and notified state
- return setCursorDeadAndNotified(self, callback);
- }
-
- // Increment the current cursor limit
- self.cursorState.currentLimit += 1;
-
- // Get the document
- var doc = self.cursorState.documents[self.cursorState.cursorIndex++];
-
- // Transform the doc with passed in transformation method if provided
- if(self.cursorState.transforms && typeof self.cursorState.transforms.doc == 'function') {
- doc = self.cursorState.transforms.doc(doc);
- }
-
- // Return the document
- handleCallback(callback, null, doc);
- }
-}
-
-/**
- * Retrieve the next document from the cursor
- * @method
- * @param {resultCallback} callback A callback function
- */
-Cursor.prototype.next = function(callback) {
- nextFunction(this, callback);
-}
-
-module.exports = Cursor;
http://git-wip-us.apache.org/repos/asf/couchdb-nmo/blob/6436833c/node_modules/couchbulkimporter/node_modules/mongodb/node_modules/mongodb-core/lib/error.js
----------------------------------------------------------------------
diff --git a/node_modules/couchbulkimporter/node_modules/mongodb/node_modules/mongodb-core/lib/error.js b/node_modules/couchbulkimporter/node_modules/mongodb/node_modules/mongodb-core/lib/error.js
deleted file mode 100644
index 4e17ef3..0000000
--- a/node_modules/couchbulkimporter/node_modules/mongodb/node_modules/mongodb-core/lib/error.js
+++ /dev/null
@@ -1,44 +0,0 @@
-"use strict";
-
-/**
- * Creates a new MongoError
- * @class
- * @augments Error
- * @param {string} message The error message
- * @return {MongoError} A MongoError instance
- */
-function MongoError(message) {
- this.name = 'MongoError';
- this.message = message;
- Error.captureStackTrace(this, MongoError);
-}
-
-/**
- * Creates a new MongoError object
- * @method
- * @param {object} options The error options
- * @return {MongoError} A MongoError instance
- */
-MongoError.create = function(options) {
- var err = null;
-
- if(options instanceof Error) {
- err = new MongoError(options.message);
- err.stack = options.stack;
- } else if(typeof options == 'string') {
- err = new MongoError(options);
- } else {
- err = new MongoError(options.message || options.errmsg || options.$err || "n/a");
- // Other options
- for(var name in options) {
- err[name] = options[name];
- }
- }
-
- return err;
-}
-
-// Extend JavaScript error
-MongoError.prototype = new Error;
-
-module.exports = MongoError;
http://git-wip-us.apache.org/repos/asf/couchdb-nmo/blob/6436833c/node_modules/couchbulkimporter/node_modules/mongodb/node_modules/mongodb-core/lib/tools/smoke_plugin.js
----------------------------------------------------------------------
diff --git a/node_modules/couchbulkimporter/node_modules/mongodb/node_modules/mongodb-core/lib/tools/smoke_plugin.js b/node_modules/couchbulkimporter/node_modules/mongodb/node_modules/mongodb-core/lib/tools/smoke_plugin.js
deleted file mode 100644
index dcceda4..0000000
--- a/node_modules/couchbulkimporter/node_modules/mongodb/node_modules/mongodb-core/lib/tools/smoke_plugin.js
+++ /dev/null
@@ -1,59 +0,0 @@
-var fs = require('fs');
-
-/* Note: because this plugin uses process.on('uncaughtException'), only one
- * of these can exist at any given time. This plugin and anything else that
- * uses process.on('uncaughtException') will conflict. */
-exports.attachToRunner = function(runner, outputFile) {
- var smokeOutput = { results : [] };
- var runningTests = {};
-
- var integraPlugin = {
- beforeTest: function(test, callback) {
- test.startTime = Date.now();
- runningTests[test.name] = test;
- callback();
- },
- afterTest: function(test, callback) {
- smokeOutput.results.push({
- status: test.status,
- start: test.startTime,
- end: Date.now(),
- test_file: test.name,
- exit_code: 0,
- url: ""
- });
- delete runningTests[test.name];
- callback();
- },
- beforeExit: function(obj, callback) {
- fs.writeFile(outputFile, JSON.stringify(smokeOutput), function() {
- callback();
- });
- }
- };
-
- // In case of exception, make sure we write file
- process.on('uncaughtException', function(err) {
- // Mark all currently running tests as failed
- for (var testName in runningTests) {
- smokeOutput.results.push({
- status: "fail",
- start: runningTests[testName].startTime,
- end: Date.now(),
- test_file: testName,
- exit_code: 0,
- url: ""
- });
- }
-
- // write file
- fs.writeFileSync(outputFile, JSON.stringify(smokeOutput));
-
- // Standard NodeJS uncaught exception handler
- console.error(err.stack);
- process.exit(1);
- });
-
- runner.plugin(integraPlugin);
- return integraPlugin;
-};
http://git-wip-us.apache.org/repos/asf/couchdb-nmo/blob/6436833c/node_modules/couchbulkimporter/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/command_result.js
----------------------------------------------------------------------
diff --git a/node_modules/couchbulkimporter/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/command_result.js b/node_modules/couchbulkimporter/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/command_result.js
deleted file mode 100644
index ff7bf1b..0000000
--- a/node_modules/couchbulkimporter/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/command_result.js
+++ /dev/null
@@ -1,37 +0,0 @@
-"use strict";
-
-var setProperty = require('../connection/utils').setProperty
- , getProperty = require('../connection/utils').getProperty
- , getSingleProperty = require('../connection/utils').getSingleProperty;
-
-/**
- * Creates a new CommandResult instance
- * @class
- * @param {object} result CommandResult object
- * @param {Connection} connection A connection instance associated with this result
- * @return {CommandResult} A cursor instance
- */
-var CommandResult = function(result, connection) {
- this.result = result;
- this.connection = connection;
-}
-
-/**
- * Convert CommandResult to JSON
- * @method
- * @return {object}
- */
-CommandResult.prototype.toJSON = function() {
- return this.result;
-}
-
-/**
- * Convert CommandResult to String representation
- * @method
- * @return {string}
- */
-CommandResult.prototype.toString = function() {
- return JSON.stringify(this.toJSON());
-}
-
-module.exports = CommandResult;
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/couchdb-nmo/blob/6436833c/node_modules/couchbulkimporter/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/mongos.js
----------------------------------------------------------------------
diff --git a/node_modules/couchbulkimporter/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/mongos.js b/node_modules/couchbulkimporter/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/mongos.js
deleted file mode 100644
index c54514a..0000000
--- a/node_modules/couchbulkimporter/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/mongos.js
+++ /dev/null
@@ -1,1000 +0,0 @@
-"use strict";
-
-var inherits = require('util').inherits
- , f = require('util').format
- , b = require('bson')
- , bindToCurrentDomain = require('../connection/utils').bindToCurrentDomain
- , EventEmitter = require('events').EventEmitter
- , BasicCursor = require('../cursor')
- , BSON = require('bson').native().BSON
- , BasicCursor = require('../cursor')
- , Server = require('./server')
- , Logger = require('../connection/logger')
- , ReadPreference = require('./read_preference')
- , Session = require('./session')
- , MongoError = require('../error');
-
-/**
- * @fileOverview The **Mongos** class is a class that represents a Mongos Proxy topology and is
- * used to construct connections.
- *
- * @example
- * var Mongos = require('mongodb-core').Mongos
- * , ReadPreference = require('mongodb-core').ReadPreference
- * , assert = require('assert');
- *
- * var server = new Mongos([{host: 'localhost', port: 30000}]);
- * // Wait for the connection event
- * server.on('connect', function(server) {
- * server.destroy();
- * });
- *
- * // Start connecting
- * server.connect();
- */
-
-var DISCONNECTED = 'disconnected';
-var CONNECTING = 'connecting';
-var CONNECTED = 'connected';
-var DESTROYED = 'destroyed';
-
-// All bson types
-var bsonTypes = [b.Long, b.ObjectID, b.Binary, b.Code, b.DBRef, b.Symbol, b.Double, b.Timestamp, b.MaxKey, b.MinKey];
-// BSON parser
-var bsonInstance = null;
-
-// Instance id
-var mongosId = 0;
-
-//
-// Clone the options
-var cloneOptions = function(options) {
- var opts = {};
- for(var name in options) {
- opts[name] = options[name];
- }
- return opts;
-}
-
-var State = function(readPreferenceStrategies) {
- // Internal state
- this.s = {
- connectedServers: []
- , disconnectedServers: []
- , readPreferenceStrategies: readPreferenceStrategies
- }
-}
-
-//
-// A Mongos connected
-State.prototype.connected = function(server) {
- // Locate in disconnected servers and remove
- this.s.disconnectedServers = this.s.disconnectedServers.filter(function(s) {
- return !s.equals(server);
- });
-
- var found = false;
- // Check if the server exists
- this.s.connectedServers.forEach(function(s) {
- if(s.equals(server)) found = true;
- });
-
- // Add to disconnected list if it does not already exist
- if(!found) this.s.connectedServers.push(server);
-}
-
-//
-// A Mongos disconnected
-State.prototype.disconnected = function(server) {
- // Locate in disconnected servers and remove
- this.s.connectedServers = this.s.connectedServers.filter(function(s) {
- return !s.equals(server);
- });
-
- var found = false;
- // Check if the server exists
- this.s.disconnectedServers.forEach(function(s) {
- if(s.equals(server)) found = true;
- });
-
- // Add to disconnected list if it does not already exist
- if(!found) this.s.disconnectedServers.push(server);
-}
-
-//
-// Return the list of disconnected servers
-State.prototype.disconnectedServers = function() {
- return this.s.disconnectedServers.slice(0);
-}
-
-//
-// Get connectedServers
-State.prototype.connectedServers = function() {
- return this.s.connectedServers.slice(0)
-}
-
-//
-// Get all servers
-State.prototype.getAll = function() {
- return this.s.connectedServers.slice(0).concat(this.s.disconnectedServers);
-}
-
-//
-// Get all connections
-State.prototype.getAllConnections = function() {
- var connections = [];
- this.s.connectedServers.forEach(function(e) {
- connections = connections.concat(e.connections());
- });
- return connections;
-}
-
-//
-// Destroy the state
-State.prototype.destroy = function() {
- // Destroy any connected servers
- while(this.s.connectedServers.length > 0) {
- var server = this.s.connectedServers.shift();
-
- // Remove any non used handlers
- ['error', 'close', 'timeout', 'connect'].forEach(function(e) {
- server.removeAllListeners(e);
- })
-
- // Server destroy
- server.destroy();
- // Add to list of disconnected servers
- this.s.disconnectedServers.push(server);
- }
-}
-
-//
-// Are we connected
-State.prototype.isConnected = function() {
- return this.s.connectedServers.length > 0;
-}
-
-//
-// Pick a server
-State.prototype.pickServer = function(readPreference) {
- readPreference = readPreference || ReadPreference.primary;
-
- // Do we have a custom readPreference strategy, use it
- if(this.s.readPreferenceStrategies != null && this.s.readPreferenceStrategies[readPreference] != null) {
- return this.s.readPreferenceStrategies[readPreference].pickServer(connectedServers, readPreference);
- }
-
- // No valid connections
- if(this.s.connectedServers.length == 0) throw new MongoError("no mongos proxy available");
- // Pick first one
- return this.s.connectedServers[0];
-}
-
-/**
- * Creates a new Mongos instance
- * @class
- * @param {array} seedlist A list of seeds for the replicaset
- * @param {number} [options.reconnectTries=30] Reconnect retries for HA if no servers available
- * @param {number} [options.haInterval=5000] The High availability period for replicaset inquiry
- * @param {boolean} [options.emitError=false] Server will emit errors events
- * @param {Cursor} [options.cursorFactory=Cursor] The cursor factory class used for all query cursors
- * @param {number} [options.size=5] Server connection pool size
- * @param {boolean} [options.keepAlive=true] TCP Connection keep alive enabled
- * @param {number} [options.keepAliveInitialDelay=0] Initial delay before TCP keep alive enabled
- * @param {boolean} [options.noDelay=true] TCP Connection no delay
- * @param {number} [options.connectionTimeout=1000] TCP Connection timeout setting
- * @param {number} [options.socketTimeout=0] TCP Socket timeout setting
- * @param {boolean} [options.singleBufferSerializtion=true] Serialize into single buffer, trade of peak memory for serialization speed
- * @param {boolean} [options.ssl=false] Use SSL for connection
- * @param {Buffer} [options.ca] SSL Certificate store binary buffer
- * @param {Buffer} [options.cert] SSL Certificate binary buffer
- * @param {Buffer} [options.key] SSL Key file binary buffer
- * @param {string} [options.passphrase] SSL Certificate pass phrase
- * @param {boolean} [options.rejectUnauthorized=true] Reject unauthorized server certificates
- * @param {boolean} [options.promoteLongs=true] Convert Long values from the db into Numbers if they fit into 53 bits
- * @return {Mongos} A cursor instance
- * @fires Mongos#connect
- * @fires Mongos#joined
- * @fires Mongos#left
- */
-var Mongos = function(seedlist, options) {
- var self = this;
- options = options || {};
-
- // Add event listener
- EventEmitter.call(this);
-
- // Validate seedlist
- if(!Array.isArray(seedlist)) throw new MongoError("seedlist must be an array");
- // Validate list
- if(seedlist.length == 0) throw new MongoError("seedlist must contain at least one entry");
- // Validate entries
- seedlist.forEach(function(e) {
- if(typeof e.host != 'string' || typeof e.port != 'number')
- throw new MongoError("seedlist entry must contain a host and port");
- });
-
- // BSON Parser, ensure we have a single instance
- bsonInstance = bsonInstance == null ? new BSON(bsonTypes) : bsonInstance;
- // Pick the right bson parser
- var bson = options.bson ? options.bson : bsonInstance;
- // Add bson parser to options
- options.bson = bson;
-
- // The Mongos state
- this.s = {
- // Seed list for sharding passed in
- seedlist: seedlist
- // Passed in options
- , options: options
- // Logger
- , logger: Logger('Mongos', options)
- // Reconnect tries
- , reconnectTries: options.reconnectTries || 30
- // Ha interval
- , haInterval: options.haInterval || 5000
- // Have omitted fullsetup
- , fullsetup: false
- // Cursor factory
- , Cursor: options.cursorFactory || BasicCursor
- // Current credentials used for auth
- , credentials: []
- // BSON Parser
- , bsonInstance: bsonInstance
- , bson: bson
- // Default state
- , state: DISCONNECTED
- // Swallow or emit errors
- , emitError: typeof options.emitError == 'boolean' ? options.emitError : false
- // Contains any alternate strategies for picking
- , readPreferenceStrategies: {}
- // Auth providers
- , authProviders: {}
- // Unique instance id
- , id: mongosId++
- // Authentication in progress
- , authInProgress: false
- // Servers added while auth in progress
- , authInProgressServers: []
- // Current retries left
- , retriesLeft: options.reconnectTries || 30
- // Do we have a not connected handler
- , disconnectHandler: options.disconnectHandler
- }
-
- // Set up the connection timeout for the options
- options.connectionTimeout = options.connectionTimeout || 1000;
-
- // Create a new state for the mongos
- this.s.mongosState = new State(this.s.readPreferenceStrategies);
-
- // BSON property (find a server and pass it along)
- Object.defineProperty(this, 'bson', {
- enumerable: true, get: function() {
- var servers = self.s.mongosState.getAll();
- return servers.length > 0 ? servers[0].bson : null;
- }
- });
-
- Object.defineProperty(this, 'id', {
- enumerable:true, get: function() { return self.s.id; }
- });
-
- Object.defineProperty(this, 'type', {
- enumerable:true, get: function() { return 'mongos'; }
- });
-
- Object.defineProperty(this, 'haInterval', {
- enumerable:true, get: function() { return self.s.haInterval; }
- });
-
- Object.defineProperty(this, 'state', {
- enumerable:true, get: function() { return self.s.mongosState; }
- });
-}
-
-inherits(Mongos, EventEmitter);
-
-/**
- * Name of BSON parser currently used
- * @method
- * @return {string}
- */
-Mongos.prototype.parserType = function() {
- if(this.s.bson.serialize.toString().indexOf('[native code]') != -1)
- return 'c++';
- return 'js';
-}
-
-/**
- * Execute a command
- * @method
- * @param {string} type Type of BSON parser to use (c++ or js)
- */
-Mongos.prototype.setBSONParserType = function(type) {
- var nBSON = null;
-
- if(type == 'c++') {
- nBSON = require('bson').native().BSON;
- } else if(type == 'js') {
- nBSON = require('bson').pure().BSON;
- } else {
- throw new MongoError(f("% parser not supported", type));
- }
-
- this.s.options.bson = new nBSON(bsonTypes);
-}
-
-/**
- * Returns the last known ismaster document for this server
- * @method
- * @return {object}
- */
-Mongos.prototype.lastIsMaster = function() {
- var connectedServers = this.s.mongosState.connectedServers();
- if(connectedServers.length > 0) return connectedServers[0].lastIsMaster();
- return null;
-}
-
-/**
- * Initiate server connect
- * @method
- */
-Mongos.prototype.connect = function(_options) {
- var self = this;
- // Start replicaset inquiry process
- setTimeout(mongosInquirer(self, self.s), self.s.haInterval);
- // Additional options
- if(_options) for(var name in _options) self.s.options[name] = _options[name];
- // For all entries in the seedlist build a server instance
- self.s.seedlist.forEach(function(e) {
- // Clone options
- var opts = cloneOptions(self.s.options);
- // Add host and port
- opts.host = e.host;
- opts.port = e.port;
- opts.reconnect = false;
- opts.readPreferenceStrategies = self.s.readPreferenceStrategies;
- // Share the auth store
- opts.authProviders = self.s.authProviders;
- // Don't emit errors
- opts.emitError = true;
- // Create a new Server
- self.s.mongosState.disconnected(new Server(opts));
- });
-
- // Get the disconnected servers
- var servers = self.s.mongosState.disconnectedServers();
-
- // Attempt to connect to all the servers
- while(servers.length > 0) {
- // Get the server
- var server = servers.shift();
-
- // Remove any non used handlers
- ['error', 'close', 'timeout', 'connect', 'message', 'parseError'].forEach(function(e) {
- server.removeAllListeners(e);
- });
-
- // Set up the event handlers
- server.once('error', errorHandlerTemp(self, self.s, server));
- server.once('close', errorHandlerTemp(self, self.s, server));
- server.once('timeout', errorHandlerTemp(self, self.s, server));
- server.once('parseError', errorHandlerTemp(self, self.s, server));
- server.once('connect', connectHandler(self, self.s, 'connect'));
-
- if(self.s.logger.isInfo()) self.s.logger.info(f('connecting to server %s', server.name));
- // Attempt to connect
- server.connect();
- }
-}
-
-/**
- * Destroy the server connection
- * @method
- */
-Mongos.prototype.destroy = function(emitClose) {
- this.s.state = DESTROYED;
- // Emit close
- if(emitClose && self.listeners('close').length > 0) self.emit('close', self);
- // Destroy the state
- this.s.mongosState.destroy();
-}
-
-/**
- * Figure out if the server is connected
- * @method
- * @return {boolean}
- */
-Mongos.prototype.isConnected = function() {
- return this.s.mongosState.isConnected();
-}
-
-/**
- * Figure out if the server instance was destroyed by calling destroy
- * @method
- * @return {boolean}
- */
-Mongos.prototype.isDestroyed = function() {
- return this.s.state == DESTROYED;
-}
-
-//
-// Operations
-//
-
-/**
- * Insert one or more documents
- * @method
- * @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
- * @param {array} ops An array of documents to insert
- * @param {boolean} [options.ordered=true] Execute in order or out of order
- * @param {object} [options.writeConcern={}] Write concern for the operation
- * @param {Boolean} [options.serializeFunctions=false] Specify if functions on an object should be serialized.
- * @param {Boolean} [options.ignoreUndefined=false] Specify if the BSON serializer should ignore undefined fields.
- * @param {opResultCallback} callback A callback function
- */
-Mongos.prototype.insert = function(ns, ops, options, callback) {
- if(typeof options == 'function') callback = options, options = {};
- if(this.s.state == DESTROYED) return callback(new MongoError(f('topology was destroyed')));
- // Topology is not connected, save the call in the provided store to be
- // Executed at some point when the handler deems it's reconnected
- if(!this.isConnected() && this.s.disconnectHandler != null) {
- callback = bindToCurrentDomain(callback);
- return this.s.disconnectHandler.add('insert', ns, ops, options, callback);
- }
-
- executeWriteOperation(this.s, 'insert', ns, ops, options, callback);
-}
-
-/**
- * Perform one or more update operations
- * @method
- * @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
- * @param {array} ops An array of updates
- * @param {boolean} [options.ordered=true] Execute in order or out of order
- * @param {object} [options.writeConcern={}] Write concern for the operation
- * @param {Boolean} [options.serializeFunctions=false] Specify if functions on an object should be serialized.
- * @param {Boolean} [options.ignoreUndefined=false] Specify if the BSON serializer should ignore undefined fields.
- * @param {opResultCallback} callback A callback function
- */
-Mongos.prototype.update = function(ns, ops, options, callback) {
- if(typeof options == 'function') callback = options, options = {};
- if(this.s.state == DESTROYED) return callback(new MongoError(f('topology was destroyed')));
- // Topology is not connected, save the call in the provided store to be
- // Executed at some point when the handler deems it's reconnected
- if(!this.isConnected() && this.s.disconnectHandler != null) {
- callback = bindToCurrentDomain(callback);
- return this.s.disconnectHandler.add('update', ns, ops, options, callback);
- }
-
- executeWriteOperation(this.s, 'update', ns, ops, options, callback);
-}
-
-/**
- * Perform one or more remove operations
- * @method
- * @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
- * @param {array} ops An array of removes
- * @param {boolean} [options.ordered=true] Execute in order or out of order
- * @param {object} [options.writeConcern={}] Write concern for the operation
- * @param {Boolean} [options.serializeFunctions=false] Specify if functions on an object should be serialized.
- * @param {Boolean} [options.ignoreUndefined=false] Specify if the BSON serializer should ignore undefined fields.
- * @param {opResultCallback} callback A callback function
- */
-Mongos.prototype.remove = function(ns, ops, options, callback) {
- if(typeof options == 'function') callback = options, options = {};
- if(this.s.state == DESTROYED) return callback(new MongoError(f('topology was destroyed')));
- // Topology is not connected, save the call in the provided store to be
- // Executed at some point when the handler deems it's reconnected
- if(!this.isConnected() && this.s.disconnectHandler != null) {
- callback = bindToCurrentDomain(callback);
- return this.s.disconnectHandler.add('remove', ns, ops, options, callback);
- }
-
- executeWriteOperation(this.s, 'remove', ns, ops, options, callback);
-}
-
-/**
- * Execute a command
- * @method
- * @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
- * @param {object} cmd The command hash
- * @param {ReadPreference} [options.readPreference] Specify read preference if command supports it
- * @param {Connection} [options.connection] Specify connection object to execute command against
- * @param {Boolean} [options.serializeFunctions=false] Specify if functions on an object should be serialized.
- * @param {Boolean} [options.ignoreUndefined=false] Specify if the BSON serializer should ignore undefined fields.
- * @param {opResultCallback} callback A callback function
- */
-Mongos.prototype.command = function(ns, cmd, options, callback) {
- if(typeof options == 'function') callback = options, options = {};
- if(this.s.state == DESTROYED) return callback(new MongoError(f('topology was destroyed')));
- var self = this;
-
- // Topology is not connected, save the call in the provided store to be
- // Executed at some point when the handler deems it's reconnected
- if(!self.isConnected() && self.s.disconnectHandler != null) {
- callback = bindToCurrentDomain(callback);
- return self.s.disconnectHandler.add('command', ns, cmd, options, callback);
- }
-
- var server = null;
- // Ensure we have no options
- options = options || {};
-
- // We need to execute the command on all servers
- if(options.onAll) {
- var servers = self.s.mongosState.getAll();
- var count = servers.length;
- var cmdErr = null;
-
- for(var i = 0; i < servers.length; i++) {
- servers[i].command(ns, cmd, options, function(err, r) {
- count = count - 1;
- // Finished executing command
- if(count == 0) {
- // Was it a logout command clear any credentials
- if(cmd.logout) clearCredentials(state, ns);
- // Return the error
- callback(err, r);
- }
- });
- }
-
- return;
- }
-
-
- try {
- // Get a primary
- server = self.s.mongosState.pickServer(options.writeConcern ? ReadPreference.primary : options.readPreference);
- } catch(err) {
- return callback(err);
- }
-
- // No server returned we had an error
- if(server == null) return callback(new MongoError("no mongos found"));
- server.command(ns, cmd, options, function(err, r) {
- // Was it a logout command clear any credentials
- if(cmd.logout) clearCredentials(self.s, ns);
- callback(err, r);
- });
-}
-
-/**
- * Perform one or more remove operations
- * @method
- * @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
- * @param {{object}|{Long}} cmd Can be either a command returning a cursor or a cursorId
- * @param {object} [options.batchSize=0] Batchsize for the operation
- * @param {array} [options.documents=[]] Initial documents list for cursor
- * @param {ReadPreference} [options.readPreference] Specify read preference if command supports it
- * @param {Boolean} [options.serializeFunctions=false] Specify if functions on an object should be serialized.
- * @param {Boolean} [options.ignoreUndefined=false] Specify if the BSON serializer should ignore undefined fields.
- * @param {opResultCallback} callback A callback function
- */
-Mongos.prototype.cursor = function(ns, cmd, cursorOptions) {
- cursorOptions = cursorOptions || {};
- var FinalCursor = cursorOptions.cursorFactory || this.s.Cursor;
- return new FinalCursor(this.s.bson, ns, cmd, cursorOptions, this, this.s.options);
-}
-
-/**
- * Authenticate using a specified mechanism
- * @method
- * @param {string} mechanism The Auth mechanism we are invoking
- * @param {string} db The db we are invoking the mechanism against
- * @param {...object} param Parameters for the specific mechanism
- * @param {authResultCallback} callback A callback function
- */
-Mongos.prototype.auth = function(mechanism, db) {
- var allArgs = Array.prototype.slice.call(arguments, 0).slice(0);
- var self = this;
- var args = Array.prototype.slice.call(arguments, 2);
- var callback = args.pop();
-
- // If we don't have the mechanism fail
- if(this.s.authProviders[mechanism] == null && mechanism != 'default')
- throw new MongoError(f("auth provider %s does not exist", mechanism));
-
- // Authenticate against all the servers
- var servers = this.s.mongosState.connectedServers().slice(0);
- var count = servers.length;
- // Correct authentication
- var authenticated = true;
- var authErr = null;
- // Set auth in progress
- this.s.authInProgress = true;
-
- // Authenticate against all servers
- while(servers.length > 0) {
- var server = servers.shift();
- // Arguments without a callback
- var argsWithoutCallback = [mechanism, db].concat(args.slice(0));
- // Create arguments
- var finalArguments = argsWithoutCallback.concat([function(err, r) {
- count = count - 1;
- if(err) authErr = err;
- if(!r) authenticated = false;
-
- // We are done
- if(count == 0) {
- // We have more servers that are not authenticated, let's authenticate
- if(self.s.authInProgressServers.length > 0) {
- self.s.authInProgressServers = [];
- return self.auth.apply(self, [mechanism, db].concat(args).concat([callback]));
- }
-
- // Auth is done
- self.s.authInProgress = false;
- // Add successful credentials
- if(authErr == null) addCredentials(self.s, db, argsWithoutCallback);
- // Return the auth error
- if(authErr) return callback(authErr, false);
- // Successfully authenticated session
- callback(null, new Session({}, self));
- }
- }]);
-
- // Execute the auth
- server.auth.apply(server, finalArguments);
- }
-}
-
-//
-// Plugin methods
-//
-
-/**
- * Add custom read preference strategy
- * @method
- * @param {string} name Name of the read preference strategy
- * @param {object} strategy Strategy object instance
- */
-Mongos.prototype.addReadPreferenceStrategy = function(name, strategy) {
- if(this.s.readPreferenceStrategies == null) this.s.readPreferenceStrategies = {};
- this.s.readPreferenceStrategies[name] = strategy;
-}
-
-/**
- * Add custom authentication mechanism
- * @method
- * @param {string} name Name of the authentication mechanism
- * @param {object} provider Authentication object instance
- */
-Mongos.prototype.addAuthProvider = function(name, provider) {
- this.s.authProviders[name] = provider;
-}
-
-/**
- * Get connection
- * @method
- * @param {ReadPreference} [options.readPreference] Specify read preference if command supports it
- * @return {Connection}
- */
-Mongos.prototype.getConnection = function(options) {
- // Ensure we have no options
- options = options || {};
- // Pick the right server based on readPreference
- var server = this.s.mongosState.pickServer(options.readPreference);
- if(server == null) return null;
- // Return connection
- return server.getConnection();
-}
-
-/**
- * Get server
- * @method
- * @param {ReadPreference} [options.readPreference] Specify read preference if command supports it
- * @return {Server}
- */
-Mongos.prototype.getServer = function(options) {
- // Ensure we have no options
- options = options || {};
- // Pick the right server based on readPreference
- return this.s.mongosState.pickServer(options.readPreference);
-}
-
-/**
- * All raw connections
- * @method
- * @return {Connection[]}
- */
-Mongos.prototype.connections = function() {
- return this.s.mongosState.getAllConnections();
-}
-
-//
-// Inquires about state changes
-//
-var mongosInquirer = function(self, state) {
- return function() {
- if(state.state == DESTROYED) return
- if(state.state == CONNECTED) state.retriesLeft = state.reconnectTries;
-
- // If we have a disconnected site
- if(state.state == DISCONNECTED && state.retriesLeft == 0) {
- self.destroy();
- return self.emit('error', new MongoError(f('failed to reconnect after %s', state.reconnectTries)));
- } else if(state == DISCONNECTED) {
- state.retriesLeft = state.retriesLeft - 1;
- }
-
- // If we have a primary and a disconnect handler, execute
- // buffered operations
- if(state.mongosState.isConnected() && state.disconnectHandler) {
- state.disconnectHandler.execute();
- }
-
- // Log the information
- if(state.logger.isDebug()) state.logger.debug(f('mongos ha proceess running'));
-
- // Let's query any disconnected proxies
- var disconnectedServers = state.mongosState.disconnectedServers();
- if(disconnectedServers.length == 0) return setTimeout(mongosInquirer(self, state), state.haInterval);
-
- // Count of connections waiting to be connected
- var connectionCount = disconnectedServers.length;
- if(state.logger.isDebug()) state.logger.debug(f('mongos ha proceess found %d disconnected proxies', connectionCount));
-
- // Let's attempt to reconnect
- while(disconnectedServers.length > 0) {
- var server = disconnectedServers.shift();
- if(state.logger.isDebug()) state.logger.debug(f('attempting to connect to server %s', server.name));
-
- // Remove any listeners
- ['error', 'close', 'timeout', 'connect', 'message', 'parseError'].forEach(function(e) {
- server.removeAllListeners(e);
- });
-
- // Set up the event handlers
- server.once('error', errorHandlerTemp(self, state, server));
- server.once('close', errorHandlerTemp(self, state, server));
- server.once('timeout', errorHandlerTemp(self, state, server));
- server.once('connect', connectHandler(self, state, 'ha'));
- // Start connect
- server.connect();
- }
-
- // Let's keep monitoring but wait for possible timeout to happen
- return setTimeout(mongosInquirer(self, state), state.options.connectionTimeout + state.haInterval);
- }
-}
-
-//
-// Error handler for initial connect
-var errorHandlerTemp = function(self, state, server) {
- return function(err, server) {
- // Log the information
- if(state.logger.isInfo()) state.logger.info(f('server %s disconnected with error %s', server.name, JSON.stringify(err)));
-
- // Remove any non used handlers
- ['error', 'close', 'timeout', 'connect'].forEach(function(e) {
- server.removeAllListeners(e);
- })
-
- // Signal disconnect of server
- state.mongosState.disconnected(server);
- }
-}
-
-//
-// Handlers
-var errorHandler = function(self, state) {
- return function(err, server) {
- if(state.logger.isInfo()) state.logger.info(f('server %s errored out with %s', server.name, JSON.stringify(err)));
- state.mongosState.disconnected(server);
- // No more servers left emit close
- if(state.mongosState.connectedServers().length == 0) {
- state.state = DISCONNECTED;
- }
-
- // Signal server left
- self.emit('left', 'mongos', server);
- if(state.emitError) self.emit('error', err, server);
- }
-}
-
-var timeoutHandler = function(self, state) {
- return function(err, server) {
- if(state.logger.isInfo()) state.logger.info(f('server %s timed out', server.name));
- state.mongosState.disconnected(server);
-
- // No more servers emit close event if no entries left
- if(state.mongosState.connectedServers().length == 0) {
- state.state = DISCONNECTED;
- }
-
- // Signal server left
- self.emit('left', 'mongos', server);
- }
-}
-
-var closeHandler = function(self, state) {
- return function(err, server) {
- if(state.logger.isInfo()) state.logger.info(f('server %s closed', server.name));
- state.mongosState.disconnected(server);
-
- // No more servers left emit close
- if(state.mongosState.connectedServers().length == 0) {
- state.state = DISCONNECTED;
- }
-
- // Signal server left
- self.emit('left', 'mongos', server);
- }
-}
-
-// Connect handler
-var connectHandler = function(self, state, e) {
- return function(server) {
- if(state.logger.isInfo()) state.logger.info(f('connected to %s', server.name));
-
- // Remove any non used handlers
- ['error', 'close', 'timeout', 'connect', 'message', 'parseError'].forEach(function(e) {
- server.removeAllListeners(e);
- });
-
- // finish processing the server
- var processNewServer = function(_server) {
- // Add the server handling code
- if(_server.isConnected()) {
- _server.once('error', errorHandler(self, state));
- _server.once('close', closeHandler(self, state));
- _server.once('timeout', timeoutHandler(self, state));
- _server.once('parseError', timeoutHandler(self, state));
- }
-
- // Emit joined event
- self.emit('joined', 'mongos', _server);
-
- // Add to list connected servers
- state.mongosState.connected(_server);
-
- // Do we have a reconnect event
- if('ha' == e && state.mongosState.connectedServers().length == 1) {
- self.emit('reconnect', _server);
- }
-
- // Full setup
- if(state.mongosState.disconnectedServers().length == 0 &&
- state.mongosState.connectedServers().length > 0 &&
- !state.fullsetup) {
- state.fullsetup = true;
- self.emit('fullsetup');
- }
-
- // all connected
- if(state.mongosState.disconnectedServers().length == 0 &&
- state.mongosState.connectedServers().length == state.seedlist.length &&
- !state.all) {
- state.all = true;
- self.emit('all');
- }
-
- // Set connected
- if(state.state == DISCONNECTED) {
- state.state = CONNECTED;
- self.emit('connect', self);
- }
- }
-
- // Is there an authentication process ongoing
- if(state.authInProgress) {
- state.authInProgressServers.push(server);
- }
-
- // No credentials just process server
- if(state.credentials.length == 0) return processNewServer(server);
-
- // Do we have credentials, let's apply them all
- var count = state.credentials.length;
- // Apply the credentials
- for(var i = 0; i < state.credentials.length; i++) {
- server.auth.apply(server, state.credentials[i].concat([function(err, r) {
- count = count - 1;
- if(count == 0) processNewServer(server);
- }]));
- }
- }
-}
-
-//
-// Add server to the list if it does not exist
-var addToListIfNotExist = function(list, server) {
- var found = false;
-
- // Remove any non used handlers
- ['error', 'close', 'timeout', 'connect'].forEach(function(e) {
- server.removeAllListeners(e);
- })
-
- // Check if the server already exists
- for(var i = 0; i < list.length; i++) {
- if(list[i].equals(server)) found = true;
- }
-
- if(!found) {
- list.push(server);
- }
-}
-
-// Add the new credential for a db, removing the old
-// credential from the cache
-var addCredentials = function(state, db, argsWithoutCallback) {
- // Remove any credentials for the db
- clearCredentials(state, db + ".dummy");
- // Add new credentials to list
- state.credentials.push(argsWithoutCallback);
-}
-
-// Clear out credentials for a namespace
-var clearCredentials = function(state, ns) {
- var db = ns.split('.')[0];
- var filteredCredentials = [];
-
- // Filter out all credentials for the db the user is logging out off
- for(var i = 0; i < state.credentials.length; i++) {
- if(state.credentials[i][1] != db) filteredCredentials.push(state.credentials[i]);
- }
-
- // Set new list of credentials
- state.credentials = filteredCredentials;
-}
-
-var processReadPreference = function(cmd, options) {
- options = options || {}
- // No read preference specified
- if(options.readPreference == null) return cmd;
-}
-
-//
-// Execute write operation
-var executeWriteOperation = function(state, op, ns, ops, options, callback) {
- if(typeof options == 'function') {
- callback = options;
- options = {};
- }
-
- var server = null;
- // Ensure we have no options
- options = options || {};
- try {
- // Get a primary
- server = state.mongosState.pickServer();
- } catch(err) {
- return callback(err);
- }
-
- // No server returned we had an error
- if(server == null) return callback(new MongoError("no mongos found"));
- // Execute the command
- server[op](ns, ops, options, callback);
-}
-
-/**
- * A mongos connect event, used to verify that the connection is up and running
- *
- * @event Mongos#connect
- * @type {Mongos}
- */
-
-/**
- * A server member left the mongos list
- *
- * @event Mongos#left
- * @type {Mongos}
- * @param {string} type The type of member that left (mongos)
- * @param {Server} server The server object that left
- */
-
-/**
- * A server member joined the mongos list
- *
- * @event Mongos#joined
- * @type {Mongos}
- * @param {string} type The type of member that left (mongos)
- * @param {Server} server The server object that joined
- */
-
-module.exports = Mongos;
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/couchdb-nmo/blob/6436833c/node_modules/couchbulkimporter/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/read_preference.js
----------------------------------------------------------------------
diff --git a/node_modules/couchbulkimporter/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/read_preference.js b/node_modules/couchbulkimporter/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/read_preference.js
deleted file mode 100644
index 913ca1b..0000000
--- a/node_modules/couchbulkimporter/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/read_preference.js
+++ /dev/null
@@ -1,106 +0,0 @@
-"use strict";
-
-var needSlaveOk = ['primaryPreferred', 'secondary', 'secondaryPreferred', 'nearest'];
-
-/**
- * @fileOverview The **ReadPreference** class is a class that represents a MongoDB ReadPreference and is
- * used to construct connections.
- *
- * @example
- * var ReplSet = require('mongodb-core').ReplSet
- * , ReadPreference = require('mongodb-core').ReadPreference
- * , assert = require('assert');
- *
- * var server = new ReplSet([{host: 'localhost', port: 30000}], {setName: 'rs'});
- * // Wait for the connection event
- * server.on('connect', function(server) {
- * var cursor = server.cursor('db.test'
- * , {find: 'db.test', query: {}}
- * , {readPreference: new ReadPreference('secondary')});
- * cursor.next(function(err, doc) {
- * server.destroy();
- * });
- * });
- *
- * // Start connecting
- * server.connect();
- */
-
-/**
- * Creates a new Pool instance
- * @class
- * @param {string} preference A string describing the preference (primary|primaryPreferred|secondary|secondaryPreferred|nearest)
- * @param {object} tags The tags object
- * @param {object} [options] Additional read preference options
- * @property {string} preference The preference string (primary|primaryPreferred|secondary|secondaryPreferred|nearest)
- * @property {object} tags The tags object
- * @property {object} options Additional read preference options
- * @return {ReadPreference}
- */
-var ReadPreference = function(preference, tags, options) {
- this.preference = preference;
- this.tags = tags;
- this.options = options;
-}
-
-/**
- * This needs slaveOk bit set
- * @method
- * @return {boolean}
- */
-ReadPreference.prototype.slaveOk = function() {
- return needSlaveOk.indexOf(this.preference) != -1;
-}
-
-/**
- * Are the two read preference equal
- * @method
- * @return {boolean}
- */
-ReadPreference.prototype.equals = function(readPreference) {
- return readPreference.preference == this.preference;
-}
-
-/**
- * Return JSON representation
- * @method
- * @return {Object}
- */
-ReadPreference.prototype.toJSON = function() {
- var readPreference = {mode: this.preference};
- if(Array.isArray(this.tags)) readPreference.tags = this.tags;
- return readPreference;
-}
-
-/**
- * Primary read preference
- * @method
- * @return {ReadPreference}
- */
-ReadPreference.primary = new ReadPreference('primary');
-/**
- * Primary Preferred read preference
- * @method
- * @return {ReadPreference}
- */
-ReadPreference.primaryPreferred = new ReadPreference('primaryPreferred');
-/**
- * Secondary read preference
- * @method
- * @return {ReadPreference}
- */
-ReadPreference.secondary = new ReadPreference('secondary');
-/**
- * Secondary Preferred read preference
- * @method
- * @return {ReadPreference}
- */
-ReadPreference.secondaryPreferred = new ReadPreference('secondaryPreferred');
-/**
- * Nearest read preference
- * @method
- * @return {ReadPreference}
- */
-ReadPreference.nearest = new ReadPreference('nearest');
-
-module.exports = ReadPreference;
\ No newline at end of file