Skip to content
This repository was archived by the owner on Feb 4, 2022. It is now read-only.

NODE-1075 reenable sharded environment for testing (core) #261

Merged
merged 2 commits into from
Dec 19, 2017
Merged

NODE-1075 reenable sharded environment for testing (core) #261

Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
aef3490
refactor(environment): modernize and subclass `EnvironmentBase`
mbroadst Dec 18, 2017
9bebb98
fix(sharded-tests): add `shardsvr` cmdline opt, wait for async fns
mbroadst Dec 18, 2017
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
358 changes: 160 additions & 198 deletions test/environments.js
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,232 +1,194 @@
'use strict';

var f = require('util').format;
var path = require('path');

var topologyManagers = require('mongodb-test-runner').topologyManagers,
ServerManager = topologyManagers.Server,
ReplSetManager = topologyManagers.ReplSet,
ShardingManager = topologyManagers.Sharded;

var replicaSetEnvironment = function() {
return {
host: 'localhost',
port: 31000,
setName: 'rs',
topology: function(self, _mongo) {
const f = require('util').format;
const path = require('path');

const EnvironmentBase = require('mongodb-test-runner').EnvironmentBase;
const topologyManagers = require('mongodb-test-runner').topologyManagers;
const ServerManager = topologyManagers.Server;
const ReplSetManager = topologyManagers.ReplSet;
const ShardingManager = topologyManagers.Sharded;

class ReplicaSetEnvironment extends EnvironmentBase {
constructor() {
super();

this.host = 'localhost';
this.port = 31000;
this.setName = 'rs';
this.topology = (self, _mongo) => {
return new _mongo.ReplSet([{ host: 'localhost', port: 31000 }], { setName: 'rs' });
},
manager: new ReplSetManager(
'mongod',
[
{
tags: { loc: 'ny' },
options: {
bind_ip: 'localhost',
port: 31000,
dbpath: f('%s/../db/31000', __dirname)
}
},
{
tags: { loc: 'sf' },
options: {
bind_ip: 'localhost',
port: 31001,
dbpath: f('%s/../db/31001', __dirname)
}
},
{
tags: { loc: 'sf ' },
priority: 0,
options: {
bind_ip: 'localhost',
port: 31002,
dbpath: f('%s/../db/31002', __dirname)
}
},
};

const genReplsetConfig = (port, options) => {
return Object.assign(
{
tags: { loc: 'sf' },
options: {
bind_ip: 'localhost',
port: 31003,
dbpath: f('%s/../db/31003', __dirname)
port: port,
dbpath: `${__dirname}/../db/${port}`
}
},
{
arbiter: true,
options: {
bind_ip: 'localhost',
port: 31004,
dbpath: f('%s/../db/31004', __dirname)
}
}
options
);
};

this.manager = new ReplSetManager(
'mongod',
[
genReplsetConfig(31000, { tags: { loc: 'ny' } }),
genReplsetConfig(31000, { tags: { loc: 'sf' } }),
genReplsetConfig(31002, { tags: { loc: 'sf' } }),
genReplsetConfig(31003, { tags: { loc: 'sf' } }),
genReplsetConfig(31000, { tags: { loc: 'sf' } }),
genReplsetConfig(31000, { arbiter: true })
],
{
replSet: 'rs'
}
)
};
};

var shardedEnvironment = function() {
var shardingManager = new ShardingManager({
mongod: 'mongod',
mongos: 'mongos'
});
);
}
}

shardingManager.addShard(
[
{
options: {
bind_ip: 'localhost',
port: 31000,
dbpath: f('%s/../db/31000', __dirname)
}
},
{
options: {
bind_ip: 'localhost',
port: 31001,
dbpath: f('%s/../db/31001', __dirname)
}
},
{
arbiter: true,
options: {
bind_ip: 'localhost',
port: 31002,
dbpath: f('%s/../db/31002', __dirname)
}
}
],
const genMongosConfig = (port, options) => {
return Object.assign(
{
replSet: 'rs1'
}
);

shardingManager.addShard(
[
{
options: {
bind_ip: 'localhost',
port: 31010,
dbpath: f('%s/../db/31010', __dirname)
}
},
{
options: {
bind_ip: 'localhost',
port: 31011,
dbpath: f('%s/../db/31011', __dirname)
}
},
{
arbiter: true,
options: {
bind_ip: 'localhost',
port: 31012,
dbpath: f('%s/../db/31012', __dirname)
}
options: {
bind_ip: 'localhost',
port: port,
dbpath: `${__dirname}/../db/${port}`,
shardsvr: null
}
],
{
replSet: 'rs2'
}
},
options
);
};

shardingManager.addConfigurationServers(
[
{
options: {
bind_ip: 'localhost',
port: 35000,
dbpath: f('%s/../db/35000', __dirname)
}
},
{
options: {
bind_ip: 'localhost',
port: 35001,
dbpath: f('%s/../db/35001', __dirname)
}
},
{
options: {
bind_ip: 'localhost',
port: 35002,
dbpath: f('%s/../db/35002', __dirname)
}
}
],
const genConfigServerConfig = (port, options) => {
return Object.assign(
{
replSet: 'rs3'
}
);

shardingManager.addProxies(
[
{
bind_ip: 'localhost',
port: 51000,
configdb: 'localhost:35000,localhost:35001,localhost:35002'
},
{
options: {
bind_ip: 'localhost',
port: 51001,
configdb: 'localhost:35000,localhost:35001,localhost:35002'
port: port,
dbpath: `${__dirname}/../db/${port}`
}
],
{
binary: 'mongos'
}
},
options
);
};

return {
host: 'localhost',
port: 51000,
topology: function(self, _mongo) {
class ShardedEnvironment extends EnvironmentBase {
constructor() {
super();

this.host = 'localhost';
this.port = 51000;
this.topology = (self, _mongo) => {
return new _mongo.Mongos([{ host: 'localhost', port: 51000 }]);
},
manager: new ShardingManager()
};
};
};

var authEnvironment = function() {
return {
host: 'localhost',
port: 27017,
manager: new ServerManager('mongod', {
this.manager = new ShardingManager({
mongod: 'mongod',
mongos: 'mongos'
});
}

setup(callback) {
const shardingManager = this.manager;
const shardPromise = Promise.all([
shardingManager.addShard(
[genMongosConfig(31000), genMongosConfig(31001), genMongosConfig(31002, { arbiter: true })],
{
replSet: 'rs1'
}
),
shardingManager.addShard(
[genMongosConfig(31010), genMongosConfig(31011), genMongosConfig(31012, { arbiter: true })],
{
replSet: 'rs2'
}
)
]);

shardPromise
.then(() =>
shardingManager.addConfigurationServers(
[
genConfigServerConfig(35000),
genConfigServerConfig(35001),
genConfigServerConfig(35002)
],
{
replSet: 'rs3'
}
)
)
.then(() =>
shardingManager.addProxies(
[
{
bind_ip: 'localhost',
port: 51000,
configdb: 'localhost:35000,localhost:35001,localhost:35002'
},
{
bind_ip: 'localhost',
port: 51001,
configdb: 'localhost:35000,localhost:35001,localhost:35002'
}
],
{
binary: 'mongos'
}
)
)
.then(() => callback())
.catch(err => callback(err));
}
}

class AuthEnvironment extends EnvironmentBase {
constructor() {
super();

this.host = 'localhost';
this.port = 27017;
this.manager = new ServerManager('mongod', {
dbpath: path.join(path.resolve('db'), f('data-%d', 27017)),
auth: null
})
};
};
});
}
}

class SingleEnvironment extends EnvironmentBase {
constructor() {
super();

var singleEnvironment = function() {
return {
host: 'localhost',
port: 27017,
manager: new ServerManager('mongod', {
this.host = 'localhost';
this.port = 27017;
this.manager = new ServerManager('mongod', {
dbpath: path.join(path.resolve('db'), f('data-%d', 27017))
})
};
};
});
}
}

var snappyEnvironment = function() {
return {
host: 'localhost',
port: 27017,
manager: new ServerManager('mongod', {
class SnappyEnvironment extends EnvironmentBase {
constructor() {
super();

this.host = 'localhost';
this.port = 27017;
this.manager = new ServerManager('mongod', {
dbpath: path.join(path.resolve('db'), f('data-%d', 27017)),
networkMessageCompressors: 'snappy'
})
};
};
});
}
}

module.exports = {
single: singleEnvironment,
replicaset: replicaSetEnvironment,
sharded: shardedEnvironment,
auth: authEnvironment,
snappy: snappyEnvironment
single: SingleEnvironment,
replicaset: ReplicaSetEnvironment,
sharded: ShardedEnvironment,
auth: AuthEnvironment,
snappy: SnappyEnvironment
};