this.close = function(forceClosed) {
server.destroy();
// We need to wash out all stored processes
if(forceClosed == true) {
storeOptions.force = forceClosed;
store.flush();
}
}
cleanup: function cleanup(done) {
var server = new Server({ host: host, port: port, databaseName: databaseName });
try {
// Wait for the connection event
server.on('connect', function(server) {
server.command(databaseName + '.$cmd', { drop: 'users' }, function(err, res) {
if (err) {
return done(err);
}
server.destroy();
return done(res);
});
});
return done();
} catch (err) {
return done(err);
}
server.connect();
}
var pingServer = function() {
// Else we need to start checking if the server is up
server = new Server({
host: host,
port: port,
connectionTimeout: 2000,
socketTimeout: 2000,
size: 1,
reconnect: false
});
// On connect let's go
server.on('connect', function(_server) {
ismaster = server.lastIsMaster();
_server.destroy();
try {
/*eslint no-sync:0*/
pid = fs.readFileSync(pidfilepath, 'ascii').trim();
} catch (err) {
return setTimeout(pingServer, 1000);
}
// Finish up
if (callback) {
var _callback = callback;
callback = null;
_callback(null, server);
}
});
var errHandler = function(err) {
if (err.code === 10185) {
try {
pid = fs.readFileSync(pidfilepath, 'ascii').trim();
} catch (err) {
return setTimeout(pingServer, 1000);
}
var _callback = callback;
callback = null;
return _callback(null, server);
}
setTimeout(pingServer, 1000);
};
// Error or close handling
server.once('error', errHandler);
server.once('close', errHandler);
server.once('timeout', errHandler);
server.once('parseError', errHandler);
// Attempt connect
server.connect();
};
var connectHandler = function() {
// Clear out all the current handlers left over
["timeout", "error", "close"].forEach(function(e) {
server.removeAllListeners(e);
});
// Set up listeners
server.once('timeout', errorHandler('timeout'));
server.once('error', errorHandler('error'));
server.once('close', errorHandler('close'));
// Emit open event
self.emit('open', null, self);
// Return correctly
try {
callback(null, self);
} catch(err) {
process.nextTick(function() { throw err; })
}
}
seed: function seed(done) {
// Default mongo cursor batch size is 101, so insert 110 records to ensure
// the cursor is functioning properly
var records = [];
for (var i = 1; i <= 110; i++) {
records.push({ name: 'user_' + i });
}
var server = new Server({ host: host, port: port, databaseName: databaseName });
try {
// Wait for the connection event
server.on('connect', function(server) {
server.insert('machinepack.users', records, { }, function(err) {
if (err) {
return done(err);
}
server.destroy();
return done();
});
});
} catch (err) {
return done(err);
}
server.connect();
},
return function(err) {
// Remove all event handlers
var events = ['timeout', 'error', 'close'];
events.forEach(function(e) {
self.removeListener(e, connectErrorHandler);
});
server.removeListener('connect', connectErrorHandler);
// Try to callback
try {
callback(err);
} catch(err) {
process.nextTick(function() { throw err; })
}
}
server.on('connect', function(_server) {
ismaster = server.lastIsMaster();
_server.destroy();
try {
/*eslint no-sync:0*/
pid = fs.readFileSync(pidfilepath, 'ascii').trim();
} catch (err) {
return setTimeout(pingServer, 1000);
}
// Finish up
if (callback) {
var _callback = callback;
callback = null;
_callback(null, server);
}
});
this.connect = function(callback) {
if (server.isConnected()) {
return callback(null, server);
}
// Else we need to start checking if the server is up
var s = new Server({
host: host,
port: port,
connectionTimeout: 2000,
socketTimeout: 2000,
size: 1,
reconnect: false,
emitError: true
});
// On connect let's go
s.on('connect', function(_server) {
server = _server;
['error', 'close', 'timeout', 'parseError'].forEach(function(e) {
server.removeAllListeners(e);
});
// If we have credentials apply them
if (credentials) {
return _server.auth(credentials.provider, credentials.db, credentials.user, credentials.password, function(err) {
if (err) {
return callback(err);
}
callback(null, _server);
});
}
callback(null, _server);
});
// Error
var e = function(err) {
callback(err, null);
};
// Error or close handling
s.once('error', e);
s.once('close', e);
s.once('timeout', e);
// Attempt connect
s.connect();
};
server.on('connect', function(_server) {
ismaster = server.lastIsMaster();
_server.destroy();
// Heap storage engine, no lock file available
if (storageEngine === null) {
try {
// Read the pidfile
/*eslint no-sync:0*/
fs.readFileSync(path.join(dbpath, 'mongod.lock'), 'ascii').trim();
} catch (err) {
return setTimeout(pingServer, 1000);
}
}
// Finish up
if (callback) {
var _callback = callback;
callback = null;
_callback(null, null);
}
});
this.isConnected = function() {
return server.isConnected();
}
this.remove = function(ns, ops, options, callback) {
server.remove(ns, ops, options, callback);
}
test('trace simple command', function (t) {
resetAgent(function (endpoint, headers, data, cb) {
var groups = [
'system.$cmd.ismaster',
// 'opbeat.$cmd.command', // only appears in mongodb-core 1.x
'opbeat.test.insert',
'opbeat.test.update',
'opbeat.test.remove',
'opbeat.test.find'
]
t.equal(data.transactions.length, 1)
t.equal(data.transactions[0].transaction, 'foo')
t.equal(data.transactions[0].kind, 'bar')
t.equal(data.transactions[0].result, 200)
t.equal(data.traces.groups.length, groups.length + 1)
groups.forEach(function (signature, i) {
t.equal(data.traces.groups[i].kind, 'db.mongodb.query')
t.deepEqual(data.traces.groups[i].parents, ['transaction'])
t.equal(data.traces.groups[i].signature, signature)
t.equal(data.traces.groups[i].transaction, 'foo')
})
t.equal(data.traces.groups[groups.length].kind, 'transaction')
t.deepEqual(data.traces.groups[groups.length].parents, [])
t.equal(data.traces.groups[groups.length].signature, 'transaction')
t.equal(data.traces.groups[groups.length].transaction, 'foo')
var totalTraces = data.traces.raw[0].length - 2
var totalTime = data.traces.raw[0][0]
t.equal(data.traces.raw.length, 1)
t.equal(totalTraces, groups.length + 2) // +1 for an extra ismaster command, +1 for the root trace
for (var i = 1; i < totalTraces + 1; i++) {
t.equal(data.traces.raw[0][i].length, 3)
t.ok(data.traces.raw[0][i][0] >= 0, 'group index should be >= 0')
t.ok(data.traces.raw[0][i][0] < data.traces.groups.length, 'group index should be within allowed range')
t.ok(data.traces.raw[0][i][1] >= 0)
t.ok(data.traces.raw[0][i][2] <= totalTime)
}
t.equal(data.traces.raw[0][totalTraces][1], 0, 'root trace should start at 0')
t.equal(data.traces.raw[0][totalTraces][2], data.traces.raw[0][0], 'root trace should last to total time')
t.deepEqual(data.transactions[0].durations, [data.traces.raw[0][0]])
t.end()
})
var server = new Server({})
agent.startTransaction('foo', 'bar')
// test example lifted from https://github.com/christkv/mongodb-core/blob/2.0/README.md#connecting-to-mongodb
server.on('connect', function (_server) {
_server.command('system.$cmd', {ismaster: true}, function (err, results) {
t.error(err)
t.equal(results.result.ismaster, true)
_server.insert('opbeat.test', [{a: 1}, {a: 2}], {writeConcern: {w: 1}, ordered: true}, function (err, results) {
t.error(err)
t.equal(results.result.n, 2)
_server.update('opbeat.test', [{q: {a: 1}, u: {'$set': {b: 1}}}], {writeConcern: {w: 1}, ordered: true}, function (err, results) {
t.error(err)
t.equal(results.result.n, 1)
_server.remove('opbeat.test', [{q: {a: 1}, limit: 1}], {writeConcern: {w: 1}, ordered: true}, function (err, results) {
t.error(err)
t.equal(results.result.n, 1)
var cursor = _server.cursor('opbeat.test', {find: 'opbeat.test', query: {a: 2}})
cursor.next(function (err, doc) {
t.error(err)
t.equal(doc.a, 2)
_server.command('system.$cmd', {ismaster: true}, function (err, result) {
t.error(err)
agent.endTransaction()
_server.destroy()
agent._instrumentation._queue._flush()
})
})
})
})
})
})
})
server.connect()
})
this.lastIsMaster = function() {
return server.lastIsMaster();
}
this.connect = function(db, _options, callback) {
if('function' === typeof _options) callback = _options, _options = {};
if(_options == null) _options = {};
if(!('function' === typeof callback)) callback = null;
options = _options;
// Update bufferMaxEntries
storeOptions.bufferMaxEntries = db.bufferMaxEntries;
// Error handler
var connectErrorHandler = function(event) {
return function(err) {
// Remove all event handlers
var events = ['timeout', 'error', 'close'];
events.forEach(function(e) {
self.removeListener(e, connectErrorHandler);
});
server.removeListener('connect', connectErrorHandler);
// Try to callback
try {
callback(err);
} catch(err) {
process.nextTick(function() { throw err; })
}
}
}
// Actual handler
var errorHandler = function(event) {
return function(err) {
if(event != 'error') {
self.emit(event, err);
}
}
}
// Error handler
var reconnectHandler = function(err) {
self.emit('reconnect', self);
store.execute();
}
// Connect handler
var connectHandler = function() {
// Clear out all the current handlers left over
["timeout", "error", "close"].forEach(function(e) {
server.removeAllListeners(e);
});
// Set up listeners
server.once('timeout', errorHandler('timeout'));
server.once('error', errorHandler('error'));
server.once('close', errorHandler('close'));
// Emit open event
self.emit('open', null, self);
// Return correctly
try {
callback(null, self);
} catch(err) {
process.nextTick(function() { throw err; })
}
}
// Set up listeners
server.once('timeout', connectErrorHandler('timeout'));
server.once('error', connectErrorHandler('error'));
server.once('close', connectErrorHandler('close'));
server.once('connect', connectHandler);
// Reconnect server
server.on('reconnect', reconnectHandler);
// Start connection
server.connect(_options);
}
this.parserType = function() {
return server.parserType();
}
var Server = function(host, port, options) {
options = options || {};
if(!(this instanceof Server)) return new Server(host, port, options);
EventEmitter.call(this);
var self = this;
// Store option defaults
var storeOptions = {
force: false
, bufferMaxEntries: -1
}
// Shared global store
var store = options.store || new Store(self, storeOptions);
// Detect if we have a socket connection
if(host.indexOf('\/') != -1) {
if(port != null && typeof port == 'object') {
options = port;
port = null;
}
} else if(port == null) {
throw new MongoError('port must be specified');
}
// Clone options
var clonedOptions = shallowClone(options);
clonedOptions.host = host;
clonedOptions.port = port;
// Reconnect
var reconnect = typeof options.auto_reconnect == 'boolean' ? options.auto_reconnect : true;
var emitError = typeof options.emitError == 'boolean' ? options.emitError : true;
var poolSize = options.poolSize || 5;
// Socket options passed down
if(options.socketOptions) {
if(options.socketOptions.connectTimeoutMS)
clonedOptions.connectionTimeout = options.socketOptions.connectTimeoutMS;
if(options.socketOptions.socketTimeoutMS)
clonedOptions.socketTimeout = options.socketOptions.socketTimeoutMS;
}
// Add the cursor factory function
clonedOptions.cursorFactory = Cursor;
clonedOptions.reconnect = reconnect;
clonedOptions.emitError = emitError;
clonedOptions.size = poolSize;
// Translate the options
if(clonedOptions.sslCA) clonedOptions.ca = clonedOptions.sslCA;
if(typeof clonedOptions.sslValidate == 'boolean') clonedOptions.rejectUnauthorized = clonedOptions.sslValidate;
if(clonedOptions.sslKey) clonedOptions.key = clonedOptions.sslKey;
if(clonedOptions.sslCert) clonedOptions.cert = clonedOptions.sslCert;
if(clonedOptions.sslPass) clonedOptions.passphrase = clonedOptions.sslPass;
// Add the non connection store
clonedOptions.disconnectHandler = store;
// Create an instance of a server instance from mongodb-core
var server = new CServer(clonedOptions);
// Server capabilities
var sCapabilities = null;
// BSON property
Object.defineProperty(this, 'bson', {
enumerable: true, get: function() {
return server.bson;
}
});
// Last ismaster
Object.defineProperty(this, 'isMasterDoc', {
enumerable:true, get: function() {
return server.lastIsMaster();
}
});
// Last ismaster
Object.defineProperty(this, 'poolSize', {
enumerable:true, get: function() { return server.connections().length; }
});
Object.defineProperty(this, 'autoReconnect', {
enumerable:true, get: function() { return reconnect; }
});
Object.defineProperty(this, 'host', {
enumerable:true, get: function() { return host; }
});
Object.defineProperty(this, 'port', {
enumerable:true, get: function() { return port; }
});
this.parserType = function() {
return server.parserType();
}
// Connect
this.connect = function(db, _options, callback) {
if('function' === typeof _options) callback = _options, _options = {};
if(_options == null) _options = {};
if(!('function' === typeof callback)) callback = null;
options = _options;
// Update bufferMaxEntries
storeOptions.bufferMaxEntries = db.bufferMaxEntries;
// Error handler
var connectErrorHandler = function(event) {
return function(err) {
// Remove all event handlers
var events = ['timeout', 'error', 'close'];
events.forEach(function(e) {
self.removeListener(e, connectErrorHandler);
});
server.removeListener('connect', connectErrorHandler);
// Try to callback
try {
callback(err);
} catch(err) {
process.nextTick(function() { throw err; })
}
}
}
// Actual handler
var errorHandler = function(event) {
return function(err) {
if(event != 'error') {
self.emit(event, err);
}
}
}
// Error handler
var reconnectHandler = function(err) {
self.emit('reconnect', self);
store.execute();
}
// Connect handler
var connectHandler = function() {
// Clear out all the current handlers left over
["timeout", "error", "close"].forEach(function(e) {
server.removeAllListeners(e);
});
// Set up listeners
server.once('timeout', errorHandler('timeout'));
server.once('error', errorHandler('error'));
server.once('close', errorHandler('close'));
// Emit open event
self.emit('open', null, self);
// Return correctly
try {
callback(null, self);
} catch(err) {
process.nextTick(function() { throw err; })
}
}
// Set up listeners
server.once('timeout', connectErrorHandler('timeout'));
server.once('error', connectErrorHandler('error'));
server.once('close', connectErrorHandler('close'));
server.once('connect', connectHandler);
// Reconnect server
server.on('reconnect', reconnectHandler);
// Start connection
server.connect(_options);
}
// Server capabilities
this.capabilities = function() {
if(sCapabilities) return sCapabilities;
sCapabilities = new ServerCapabilities(server.lastIsMaster());
return sCapabilities;
}
// Command
this.command = function(ns, cmd, options, callback) {
server.command(ns, cmd, options, callback);
}
// Insert
this.insert = function(ns, ops, options, callback) {
server.insert(ns, ops, options, callback);
}
// Update
this.update = function(ns, ops, options, callback) {
server.update(ns, ops, options, callback);
}
// Remove
this.remove = function(ns, ops, options, callback) {
server.remove(ns, ops, options, callback);
}
// IsConnected
this.isConnected = function() {
return server.isConnected();
}
// Insert
this.cursor = function(ns, cmd, options) {
options.disconnectHandler = store;
return server.cursor(ns, cmd, options);
}
this.setBSONParserType = function(type) {
return server.setBSONParserType(type);
}
this.lastIsMaster = function() {
return server.lastIsMaster();
}
this.close = function(forceClosed) {
server.destroy();
// We need to wash out all stored processes
if(forceClosed == true) {
storeOptions.force = forceClosed;
store.flush();
}
}
this.auth = function() {
var args = Array.prototype.slice.call(arguments, 0);
server.auth.apply(server, args);
}
/**
* All raw connections
* @method
* @return {array}
*/
this.connections = function() {
return server.connections();
}
}
this.cursor = function(ns, cmd, options) {
options.disconnectHandler = store;
return server.cursor(ns, cmd, options);
}
this.setBSONParserType = function(type) {
return server.setBSONParserType(type);
}
this.connections = function() {
return server.connections();
}
["timeout", "error", "close"].forEach(function(e) {
server.removeAllListeners(e);
});
enumerable:true, get: function() { return server.connections().length; }
enumerable:true, get: function() {
return server.lastIsMaster();
}
this.capabilities = function() {
if(sCapabilities) return sCapabilities;
sCapabilities = new ServerCapabilities(server.lastIsMaster());
return sCapabilities;
}
var pingServer = function() {
if (server) {
server.destroy();
}
var opt = {
host: host,
port: port,
connectionTimeout: 2000,
socketTimeout: 2000,
size: 1,
reconnect: false,
emitError: typeof serverOptions.emitError === 'boolean' ? serverOptions.emitError : false
};
// Set the key
if (keys.indexOf('sslOnNormalPorts') !== -1) {
opt.ssl = true;
}
if (keys.indexOf('ssl') !== -1) {
opt.ssl = serverOptions.ssl;
}
if (keys.indexOf('ca') !== -1) {
opt.ca = serverOptions.ca;
}
if (keys.indexOf('cert') !== -1) {
opt.cert = serverOptions.cert;
}
if (keys.indexOf('rejectUnauthorized') !== -1) {
opt.rejectUnauthorized = serverOptions.rejectUnauthorized;
}
if (keys.indexOf('key') !== -1) {
opt.key = serverOptions.key;
}
if (keys.indexOf('passphrase') !== -1) {
opt.passphrase = serverOptions.passphrase;
}
// Else we need to start checking if the server is up
server = new Server(opt);
// On connect let's go
server.on('connect', function(_server) {
ismaster = server.lastIsMaster();
_server.destroy();
// Heap storage engine, no lock file available
if (storageEngine === null) {
try {
// Read the pidfile
/*eslint no-sync:0*/
fs.readFileSync(path.join(dbpath, 'mongod.lock'), 'ascii').trim();
} catch (err) {
return setTimeout(pingServer, 1000);
}
}
// Finish up
if (callback) {
var _callback = callback;
callback = null;
_callback(null, null);
}
});
var errHandler = function() {
setTimeout(pingServer, 1000);
};
// Error or close handling
server.on('error', errHandler);
server.on('close', errHandler);
server.on('timeout', errHandler);
server.once('parseError', errHandler);
// Attempt connect
server.connect();
};
this.command = function(ns, cmd, options, callback) {
server.command(ns, cmd, options, callback);
}
this.connect = function(callback) {
if (server.isConnected()) {
debug('already connected')
return callback(null, server);
}
var opt = {
host: host,
port: port,
connectionTimeout: 2000,
socketTimeout: 2000,
size: 1,
reconnect: false,
emitError: true
};
// Set the key
if (keys.indexOf('sslOnNormalPorts') !== -1) {
opt.ssl = true;
}
if (keys.indexOf('ssl') !== -1) {
opt.ssl = serverOptions.ssl;
}
if (keys.indexOf('ca') !== -1) {
opt.ca = serverOptions.ca;
}
if (keys.indexOf('cert') !== -1) {
opt.cert = serverOptions.cert;
}
if (keys.indexOf('rejectUnauthorized') !== -1) {
opt.rejectUnauthorized = serverOptions.rejectUnauthorized;
}
if (keys.indexOf('key') !== -1) {
opt.key = serverOptions.key;
}
if (keys.indexOf('passphrase') !== -1) {
opt.passphrase = serverOptions.passphrase;
}
// Else we need to start checking if the server is up
var s = new Server(opt);
// On connect let's go
s.on('connect', function(_server) {
server = _server;
['error', 'close', 'timeout', 'parseError'].forEach(function(e) {
server.removeAllListeners(e);
});
// If we have credentials apply them
if (credentials) {
return _server.auth(credentials.provider, credentials.db, credentials.user, credentials.password, function(err) {
if (err) {
return callback(err);
}
callback(null, _server);
});
}
callback(null, _server);
});
// Error
var e = function(err) {
callback(err, null);
};
// Error or close handling
s.once('error', e);
s.once('close', e);
s.once('timeout', e);
debug('attempting to connect', JSON.stringify(opt, null, 2));
s.connect();
};
this.insert = function(ns, ops, options, callback) {
server.insert(ns, ops, options, callback);
}
this.update = function(ns, ops, options, callback) {
server.update(ns, ops, options, callback);
}
const Server = require('mongodb-core').Server
, assert = require('assert');
// Set up server connection
const server = new Server({
host: 'localhost'
, port: 27017
, reconnect: true
, reconnectInterval: 50
});
// Add event listeners
server.on('connect', function(_server) {
console.log('connected!', 'disconnecting in 2 seconds');
setTimeout(function(){
console.log('disconnecting now')
_server.destroy();
}, 2000);
});
server.on('close', function() {
console.log('closed');
});
server.on('reconnect', function() {
console.log('reconnect');
});
// Start connection
server.connect();