def routers(cluster_id):
logger.debug("routers({cluster_id})".format(**locals()))
if cluster_id not in ShardedClusters():
return send_result(404)
router_docs = []
for router_info in ShardedClusters().routers(cluster_id):
# Server id is the same as router id.
server_id = router_info['id']
links = [
sharded_cluster_link('delete-router',
cluster_id,
router_id=server_id),
server_link('get-server-info', server_id)
]
router_info['links'] = links
router_docs.append(router_info)
result = {
'routers':
router_docs,
'links': [
sharded_cluster_link('get-sharded-cluster-info', cluster_id),
sharded_cluster_link('get-shards', cluster_id),
sharded_cluster_link('get-configsvrs', cluster_id),
sharded_cluster_link('get-routers', cluster_id, self_rel=True)
]
}
return send_result(200, result)
def shards(cluster_id):
logger.debug("shards({cluster_id})".format(**locals()))
if cluster_id not in ShardedClusters():
return send_result(404)
shard_docs = []
for shard_info in ShardedClusters().members(cluster_id):
shard_id = shard_info['id']
resource_id = shard_info['_id']
shard_info['links'] = [
sharded_cluster_link('get-shard-info', cluster_id, shard_id),
sharded_cluster_link('delete-shard', cluster_id, shard_id),
sharded_cluster_link('get-sharded-cluster-info', cluster_id),
]
shard_info['links'].append(_server_or_rs_link(shard_info))
shard_docs.append(shard_info)
result = {
'shards':
shard_docs,
'links': [
sharded_cluster_link('get-sharded-cluster-info', cluster_id),
sharded_cluster_link('get-shards', cluster_id, self_rel=True),
sharded_cluster_link('get-configsvrs', cluster_id),
sharded_cluster_link('get-routers', cluster_id)
]
}
return send_result(200, result)
def sh_command(cluster_id):
logger.debug("sh_command({cluster_id})".format(**locals()))
if cluster_id not in ShardedClusters():
return send_result(404)
command = get_json(request.body).get('action')
if command is None:
raise RequestError('Expected body with an {"action": ...}.')
result = {
'command_result':
ShardedClusters().command(cluster_id, command),
'links':
all_sharded_cluster_links(cluster_id, rel_to='sharded-cluster-command')
}
return send_result(200, result)
def router_add(cluster_id):
logger.debug("router_add({cluster_id})".format(**locals()))
if cluster_id not in ShardedClusters():
return send_result(404)
data = get_json(request.body)
result = ShardedClusters().router_add(cluster_id, data)
router_id = result['id']
result['links'] = [
server_link('get-server-info', router_id),
sharded_cluster_link('add-router', cluster_id, self_rel=True),
sharded_cluster_link('delete-router', cluster_id, router_id=router_id),
sharded_cluster_link('get-sharded-cluster-info', cluster_id),
sharded_cluster_link('get-routers', cluster_id),
]
return send_result(200, result)
def _sh_create(params):
cluster_id = ShardedClusters().create(params)
result = ShardedClusters().info(cluster_id)
result['links'] = all_sharded_cluster_links(cluster_id)
for router in result['routers']:
router['links'] = [
server_link('get-server-info', server_id=router['id'])
]
for cfg in result['configsvrs']:
cfg['links'] = [server_link('get-server-info', server_id=cfg['id'])]
for sh in result['shards']:
sh['links'] = [
sharded_cluster_link('get-shard-info', cluster_id, sh['id']),
_server_or_rs_link(sh)
]
return result
def shard_add(cluster_id):
logger.debug("shard_add({cluster_id})".format(**locals()))
if cluster_id not in ShardedClusters():
return send_result(404)
data = get_json(request.body)
result = ShardedClusters().member_add(cluster_id, data)
resource_id = result['_id']
shard_id = result['id']
result['links'] = [
sharded_cluster_link('get-shard-info', cluster_id, shard_id),
sharded_cluster_link('delete-shard', cluster_id, shard_id),
sharded_cluster_link('add-shard', cluster_id, self_rel=True),
sharded_cluster_link('get-sharded-cluster-info', cluster_id),
sharded_cluster_link('get-shards', cluster_id)
]
result['links'].append(_server_or_rs_link(result))
return send_result(200, result)
def info(cluster_id):
logger.debug("info({cluster_id})".format(**locals()))
if cluster_id not in ShardedClusters():
return send_result(404)
result = ShardedClusters().info(cluster_id)
result['links'] = all_sharded_cluster_links(
cluster_id, rel_to='get-sharded-cluster-info')
for router in result['routers']:
router['links'] = [
server_link('get-server-info', server_id=router['id'])
]
for cfg in result['configsvrs']:
cfg['links'] = [server_link('get-server-info', server_id=cfg['id'])]
for sh in result['shards']:
sh['links'] = [
sharded_cluster_link('get-shard-info', cluster_id, sh['id']),
_server_or_rs_link(sh)
]
return send_result(200, result)
def configsvrs(cluster_id):
logger.debug("configsvrs({cluster_id})".format(**locals()))
if cluster_id not in ShardedClusters():
return send_result(404)
config_docs = []
for config_info in ShardedClusters().configsvrs(cluster_id):
server_id = config_info['id']
config_info['links'] = [server_link('get-server-info', server_id)]
config_docs.append(config_info)
result = {
'configsvrs':
config_docs,
'links': [
sharded_cluster_link('get-sharded-cluster-info', cluster_id),
sharded_cluster_link('get-shards', cluster_id),
sharded_cluster_link('get-configsvrs', cluster_id, self_rel=True),
sharded_cluster_link('get-routers', cluster_id)
]
}
return send_result(200, result)
def sh_list():
logger.debug("sh_list()")
sharded_clusters = []
for cluster_id in ShardedClusters():
cluster_info = {'id': cluster_id}
cluster_info['links'] = all_sharded_cluster_links(
cluster_id, rel_to='get-sharded-clusters')
sharded_clusters.append(cluster_info)
response = {
'links': [
base_link('service'),
base_link('get-releases'),
sharded_cluster_link('get-sharded-clusters', self_rel=True),
sharded_cluster_link('add-sharded-cluster'),
replica_set_link('get-replica-sets'),
server_link('get-servers')
]
}
response['sharded_clusters'] = sharded_clusters
return send_result(200, response)
class ShardsTestCase(unittest.TestCase):
def setUp(self):
self.sh = ShardedClusters()
PortPool().change_range()
def tearDown(self):
self.sh.cleanup()
def test_singleton(self):
self.assertEqual(id(self.sh), id(ShardedClusters()))
def test_bool(self):
self.assertEqual(False, bool(self.sh))
self.sh.create({'id': 'sh01'})
self.assertEqual(True, bool(self.sh))
def test_operations(self):
config = {'shards': [{}, {}, {}]}
cluster = ShardedCluster(config)
self.assertEqual(len(self.sh), 0)
operator.setitem(self.sh, 1, cluster)
self.assertEqual(len(self.sh), 1)
self.assertEqual(operator.getitem(self.sh, 1)['id'], cluster.id)
operator.delitem(self.sh, 1)
self.assertEqual(len(self.sh), 0)
self.assertRaises(KeyError, operator.getitem, self.sh, 1)
cluster.cleanup()
def test_operations2(self):
self.assertTrue(len(self.sh) == 0)
config1 = {'id': 'sh01'}
config2 = {'id': 'sh02'}
self.sh.create(config1)
self.sh.create(config2)
self.assertTrue(len(self.sh) == 2)
for key in self.sh:
self.assertTrue(key in ('sh01', 'sh02'))
for key in ('sh01', 'sh02'):
self.assertTrue(key in self.sh)
def test_cleanup(self):
config1 = {'id': 'sh01'}
config2 = {'id': 'sh02'}
self.assertTrue(len(self.sh) == 0)
self.sh.create(config1)
self.sh.create(config2)
self.assertTrue(len(self.sh) == 2)
self.sh.cleanup()
self.assertTrue(len(self.sh) == 0)
def test_sh_new(self):
port = PortPool().port(check=True)
config = {
'id': 'shard_cluster_1',
'configsvrs': [{}],
'routers': [{"port": port}],
'shards': [{'id': 'sh01'}, {'id': 'sh02'},
{'id': 'sh-rs-01', 'shardParams': {'id': 'rs1', 'members': [{}, {}]}},
]
}
cluster_id = self.sh.create(config)
self.assertEqual(cluster_id, 'shard_cluster_1')
host = "{hostname}:{port}".format(hostname=HOSTNAME, port=port)
c = pymongo.MongoClient(host)
result = c.admin.command("listShards")
for shard in result['shards']:
shard['_id'] in ('sh01', 'sh02', 'sh-rs-01')
c.close()
def test_sh_new_with_auth(self):
port = PortPool().port(check=True)
config = {
'id': 'shard_cluster_1',
'auth_key': 'secret',
'login': '******',
'password': '******',
'configsvrs': [{}],
'routers': [{"port": port}],
'shards': [{'id': 'sh01'}, {'id': 'sh02'}]
}
self.sh.create(config)
host = "{hostname}:{port}".format(hostname=HOSTNAME, port=port)
c = pymongo.MongoClient(host)
self.assertRaises(pymongo.errors.OperationFailure, c.admin.command, "listShards")
c.admin.authenticate('admin', 'adminpass')
self.assertTrue(isinstance(c.admin.command("listShards"), dict))
c.close()
def test_sh_del(self):
sh1_id = self.sh.create({})
sh2_id = self.sh.create({})
self.assertEqual(len(self.sh), 2)
self.sh.remove(sh1_id)
self.assertEqual(len(self.sh), 1)
self.sh.remove(sh2_id)
self.assertEqual(len(self.sh), 0)
def test_info(self):
config = {
'configsvrs': [{}, {}, {}],
'routers': [{}, {}, {}],
'shards': [{}, {}]
}
sh_id = self.sh.create(config)
info = self.sh.info(sh_id)
self.assertTrue(isinstance(info, dict))
for item in ("shards", "configsvrs", "routers",
"mongodb_uri", "orchestration"):
self.assertTrue(item in info)
self.assertEqual(len(info['shards']), 2)
self.assertEqual(len(info['configsvrs']), 3)
self.assertEqual(len(info['routers']), 3)
mongodb_uri = info['mongodb_uri']
for router in info['routers']:
self.assertIn(Servers().hostname(router['id']), mongodb_uri)
self.assertTrue(mongodb_uri.find('mongodb://') == 0)
self.assertEqual(info['orchestration'], 'sharded_clusters')
def test_configsvrs(self):
config = {}
sh_id = self.sh.create(config)
self.assertEqual(len(self.sh.configsvrs(sh_id)), 1)
self.sh.cleanup()
config = {'configsvrs': [{}, {}, {}]}
sh_id = self.sh.create(config)
self.assertEqual(len(self.sh.configsvrs(sh_id)), 3)
def test_routers(self):
config = {}
sh_id = self.sh.create(config)
self.assertEqual(len(self.sh.routers(sh_id)), 1)
self.sh.cleanup()
config = {'routers': [{}, {}, {}]}
sh_id = self.sh.create(config)
self.assertEqual(len(self.sh.routers(sh_id)), 3)
def test_router_add(self):
config = {}
sh_id = self.sh.create(config)
self.assertEqual(len(self.sh.routers(sh_id)), 1)
self.sh.router_add(sh_id, {})
self.assertEqual(len(self.sh.routers(sh_id)), 2)
self.sh.router_add(sh_id, {})
self.assertEqual(len(self.sh.routers(sh_id)), 3)
self.sh.cleanup()
def test_members(self):
port = PortPool().port(check=True)
config = {'routers': [{'port': port}]}
sh_id = self.sh.create(config)
self.assertEqual(len(self.sh.members(sh_id)), 0)
self.sh.cleanup()
config = {'routers': [{'port': port}], 'shards': [{}, {}, {}]}
sh_id = self.sh.create(config)
self.assertEqual(len(self.sh.members(sh_id)), 3)
def test_member_info(self):
config = {'shards': [{'id': 'member1'}, {'id': 'sh-rs-01', 'shardParams': {'id': 'rs1', 'members': [{}, {}]}}]}
sh_id = self.sh.create(config)
info = self.sh.member_info(sh_id, 'member1')
self.assertEqual(info['id'], 'member1')
self.assertTrue(info['isServer'])
self.assertTrue('_id' in info)
info = self.sh.member_info(sh_id, 'sh-rs-01')
self.assertEqual(info['id'], 'sh-rs-01')
self.assertTrue(info['isReplicaSet'])
self.assertTrue('_id' in info)
def test_member_info_with_auth(self):
config = {'auth_key': 'secret', 'login': '******', 'password': '******', 'shards': [{'id': 'member1'}, {'id': 'sh-rs-01', 'shardParams': {'id': 'rs1', 'members': [{}, {}]}}]}
sh_id = self.sh.create(config)
info = self.sh.member_info(sh_id, 'member1')
self.assertEqual(info['id'], 'member1')
self.assertTrue(info['isServer'])
self.assertTrue('_id' in info)
info = self.sh.member_info(sh_id, 'sh-rs-01')
self.assertEqual(info['id'], 'sh-rs-01')
self.assertTrue(info['isReplicaSet'])
self.assertTrue('_id' in info)
def test_member_del(self):
port = PortPool().port(check=True)
config = {'routers': [{'port': port}], 'shards': [{'id': 'member1'}, {'id': 'member2'}, {'id': 'sh-rs-01', 'shardParams': {'id': 'rs1', 'members': [{}, {}]}}]}
sh_id = self.sh.create(config)
host = "{hostname}:{port}".format(hostname=HOSTNAME, port=port)
c = pymongo.MongoClient(host)
result = c.admin.command("listShards")
self.assertEqual(len(result['shards']), 3)
# remove member-host
result = self.sh.member_del(sh_id, 'member1')
self.assertEqual(len(c.admin.command("listShards")['shards']), 3)
self.assertEqual(result['state'], 'started')
self.assertEqual(result['shard'], 'member1')
time.sleep(5)
result = self.sh.member_del(sh_id, 'member1')
self.assertEqual(result['state'], 'completed')
self.assertEqual(len(c.admin.command("listShards")['shards']), 2)
self.assertEqual(result['shard'], 'member1')
# remove member-replicaset
result = self.sh.member_del(sh_id, 'sh-rs-01')
self.assertEqual(len(c.admin.command("listShards")['shards']), 2)
self.assertEqual(result['state'], 'started')
self.assertEqual(result['shard'], 'sh-rs-01')
time.sleep(7)
result = self.sh.member_del(sh_id, 'sh-rs-01')
self.assertEqual(result['state'], 'completed')
self.assertEqual(len(c.admin.command("listShards")['shards']), 1)
self.assertEqual(result['shard'], 'sh-rs-01')
def test_member_add(self):
port = PortPool().port(check=True)
config = {'routers': [{'port': port}]}
sh_id = self.sh.create(config)
host = "{hostname}:{port}".format(hostname=HOSTNAME, port=port)
c = pymongo.MongoClient(host)
self.assertEqual(len(c.admin.command("listShards")['shards']), 0)
result = self.sh.member_add(sh_id, {'id': 'test1', 'shardParams': {}})
self.assertTrue(result.get('isServer', False))
self.assertEqual(result['id'], 'test1')
self.assertEqual(len(c.admin.command("listShards")['shards']), 1)
result = self.sh.member_add(sh_id, {'id': 'test2', 'shardParams': {'id': 'rs1', 'members': [{}, {}]}})
self.assertFalse(result.get('isServer', False))
self.assertTrue(result.get('isReplicaSet', False))
self.assertEqual(result['id'], 'test2')
self.assertEqual(len(c.admin.command("listShards")['shards']), 2)
def setUp(self):
self.sh = ShardedClusters()
PortPool().change_range()
def test_singleton(self):
self.assertEqual(id(self.sh), id(ShardedClusters()))
def cleanup_storage():
ShardedClusters().cleanup()
ReplicaSets().cleanup()
Servers().cleanup()
class ShardsTestCase(unittest.TestCase):
def setUp(self):
self.sh = ShardedClusters()
PortPool().change_range()
def tearDown(self):
self.sh.cleanup()
def test_singleton(self):
self.assertEqual(id(self.sh), id(ShardedClusters()))
def test_bool(self):
self.assertEqual(False, bool(self.sh))
self.sh.create({'id': 'sh01'})
self.assertEqual(True, bool(self.sh))
def test_operations(self):
config = {'shards': [{}, {}, {}]}
cluster = ShardedCluster(config)
self.assertEqual(len(self.sh), 0)
operator.setitem(self.sh, 1, cluster)
self.assertEqual(len(self.sh), 1)
self.assertEqual(operator.getitem(self.sh, 1)['id'], cluster.id)
operator.delitem(self.sh, 1)
self.assertEqual(len(self.sh), 0)
self.assertRaises(KeyError, operator.getitem, self.sh, 1)
cluster.cleanup()
def test_operations2(self):
self.assertTrue(len(self.sh) == 0)
config1 = {'id': 'sh01'}
config2 = {'id': 'sh02'}
self.sh.create(config1)
self.sh.create(config2)
self.assertTrue(len(self.sh) == 2)
for key in self.sh:
self.assertTrue(key in ('sh01', 'sh02'))
for key in ('sh01', 'sh02'):
self.assertTrue(key in self.sh)
def test_cleanup(self):
config1 = {'id': 'sh01'}
config2 = {'id': 'sh02'}
self.assertTrue(len(self.sh) == 0)
self.sh.create(config1)
self.sh.create(config2)
self.assertTrue(len(self.sh) == 2)
self.sh.cleanup()
self.assertTrue(len(self.sh) == 0)
def test_sh_new(self):
port = PortPool().port(check=True)
config = {
'id':
'shard_cluster_1',
'configsvrs': [{}],
'routers': [{
"port": port
}],
'shards': [
{
'id': 'sh01'
},
{
'id': 'sh02'
},
{
'id': 'sh-rs-01',
'shardParams': {
'id': 'rs1',
'members': [{}, {}]
}
},
]
}
cluster_id = self.sh.create(config)
self.assertEqual(cluster_id, 'shard_cluster_1')
host = "{hostname}:{port}".format(hostname=HOSTNAME, port=port)
c = pymongo.MongoClient(host)
result = c.admin.command("listShards")
for shard in result['shards']:
shard['_id'] in ('sh01', 'sh02', 'sh-rs-01')
c.close()
def test_sh_new_with_auth(self):
port = PortPool().port(check=True)
config = {
'id': 'shard_cluster_1',
'auth_key': 'secret',
'login': '******',
'password': '******',
'configsvrs': [{}],
'routers': [{
"port": port
}],
'shards': [{
'id': 'sh01'
}, {
'id': 'sh02'
}]
}
self.sh.create(config)
host = "{hostname}:{port}".format(hostname=HOSTNAME, port=port)
c = pymongo.MongoClient(host)
self.assertRaises(pymongo.errors.OperationFailure, c.admin.command,
"listShards")
c.admin.authenticate('admin', 'adminpass')
self.assertTrue(isinstance(c.admin.command("listShards"), dict))
c.close()
def test_sh_del(self):
sh1_id = self.sh.create({})
sh2_id = self.sh.create({})
self.assertEqual(len(self.sh), 2)
self.sh.remove(sh1_id)
self.assertEqual(len(self.sh), 1)
self.sh.remove(sh2_id)
self.assertEqual(len(self.sh), 0)
def test_info(self):
config = {
'configsvrs': [{}, {}, {}],
'routers': [{}, {}, {}],
'shards': [{}, {}]
}
sh_id = self.sh.create(config)
info = self.sh.info(sh_id)
self.assertTrue(isinstance(info, dict))
for item in ("shards", "configsvrs", "routers", "mongodb_uri",
"orchestration"):
self.assertTrue(item in info)
self.assertEqual(len(info['shards']), 2)
self.assertEqual(len(info['configsvrs']), 3)
self.assertEqual(len(info['routers']), 3)
mongodb_uri = info['mongodb_uri']
for router in info['routers']:
self.assertIn(Servers().hostname(router['id']), mongodb_uri)
self.assertTrue(mongodb_uri.find('mongodb://') == 0)
self.assertEqual(info['orchestration'], 'sharded_clusters')
def test_configsvrs(self):
config = {}
sh_id = self.sh.create(config)
self.assertEqual(len(self.sh.configsvrs(sh_id)), 1)
self.sh.cleanup()
config = {'configsvrs': [{}, {}, {}]}
sh_id = self.sh.create(config)
self.assertEqual(len(self.sh.configsvrs(sh_id)), 3)
def test_routers(self):
config = {}
sh_id = self.sh.create(config)
self.assertEqual(len(self.sh.routers(sh_id)), 1)
self.sh.cleanup()
config = {'routers': [{}, {}, {}]}
sh_id = self.sh.create(config)
self.assertEqual(len(self.sh.routers(sh_id)), 3)
def test_router_add(self):
config = {}
sh_id = self.sh.create(config)
self.assertEqual(len(self.sh.routers(sh_id)), 1)
self.sh.router_add(sh_id, {})
self.assertEqual(len(self.sh.routers(sh_id)), 2)
self.sh.router_add(sh_id, {})
self.assertEqual(len(self.sh.routers(sh_id)), 3)
self.sh.cleanup()
def test_members(self):
port = PortPool().port(check=True)
config = {'routers': [{'port': port}]}
sh_id = self.sh.create(config)
self.assertEqual(len(self.sh.members(sh_id)), 0)
self.sh.cleanup()
config = {'routers': [{'port': port}], 'shards': [{}, {}, {}]}
sh_id = self.sh.create(config)
self.assertEqual(len(self.sh.members(sh_id)), 3)
def test_member_info(self):
config = {
'shards': [{
'id': 'member1'
}, {
'id': 'sh-rs-01',
'shardParams': {
'id': 'rs1',
'members': [{}, {}]
}
}]
}
sh_id = self.sh.create(config)
info = self.sh.member_info(sh_id, 'member1')
self.assertEqual(info['id'], 'member1')
self.assertTrue(info['isServer'])
self.assertTrue('_id' in info)
info = self.sh.member_info(sh_id, 'sh-rs-01')
self.assertEqual(info['id'], 'sh-rs-01')
self.assertTrue(info['isReplicaSet'])
self.assertTrue('_id' in info)
def test_member_info_with_auth(self):
config = {
'auth_key':
'secret',
'login':
'******',
'password':
'******',
'shards': [{
'id': 'member1'
}, {
'id': 'sh-rs-01',
'shardParams': {
'id': 'rs1',
'members': [{}, {}]
}
}]
}
sh_id = self.sh.create(config)
info = self.sh.member_info(sh_id, 'member1')
self.assertEqual(info['id'], 'member1')
self.assertTrue(info['isServer'])
self.assertTrue('_id' in info)
info = self.sh.member_info(sh_id, 'sh-rs-01')
self.assertEqual(info['id'], 'sh-rs-01')
self.assertTrue(info['isReplicaSet'])
self.assertTrue('_id' in info)
def test_member_del(self):
port = PortPool().port(check=True)
config = {
'routers': [{
'port': port
}],
'shards': [{
'id': 'member1'
}, {
'id': 'member2'
}, {
'id': 'sh-rs-01',
'shardParams': {
'id': 'rs1',
'members': [{}, {}]
}
}]
}
sh_id = self.sh.create(config)
host = "{hostname}:{port}".format(hostname=HOSTNAME, port=port)
c = pymongo.MongoClient(host)
result = c.admin.command("listShards")
self.assertEqual(len(result['shards']), 3)
# remove member-host
result = self.sh.member_del(sh_id, 'member1')
self.assertEqual(len(c.admin.command("listShards")['shards']), 3)
self.assertEqual(result['state'], 'started')
self.assertEqual(result['shard'], 'member1')
time.sleep(5)
result = self.sh.member_del(sh_id, 'member1')
self.assertEqual(result['state'], 'completed')
self.assertEqual(len(c.admin.command("listShards")['shards']), 2)
self.assertEqual(result['shard'], 'member1')
# remove member-replicaset
result = self.sh.member_del(sh_id, 'sh-rs-01')
self.assertEqual(len(c.admin.command("listShards")['shards']), 2)
self.assertEqual(result['state'], 'started')
self.assertEqual(result['shard'], 'sh-rs-01')
time.sleep(7)
result = self.sh.member_del(sh_id, 'sh-rs-01')
self.assertEqual(result['state'], 'completed')
self.assertEqual(len(c.admin.command("listShards")['shards']), 1)
self.assertEqual(result['shard'], 'sh-rs-01')
def test_member_add(self):
port = PortPool().port(check=True)
config = {'routers': [{'port': port}]}
sh_id = self.sh.create(config)
host = "{hostname}:{port}".format(hostname=HOSTNAME, port=port)
c = pymongo.MongoClient(host)
self.assertEqual(len(c.admin.command("listShards")['shards']), 0)
result = self.sh.member_add(sh_id, {'id': 'test1', 'shardParams': {}})
self.assertTrue(result.get('isServer', False))
self.assertEqual(result['id'], 'test1')
self.assertEqual(len(c.admin.command("listShards")['shards']), 1)
result = self.sh.member_add(sh_id, {
'id': 'test2',
'shardParams': {
'id': 'rs1',
'members': [{}, {}]
}
})
self.assertFalse(result.get('isServer', False))
self.assertTrue(result.get('isReplicaSet', False))
self.assertEqual(result['id'], 'test2')
self.assertEqual(len(c.admin.command("listShards")['shards']), 2)
def setUp(self):
self.sh = ShardedClusters()
PortPool().change_range()
ROUTES = {
Route('/sharded_clusters', method='POST'): sh_create,
Route('/sharded_clusters', method='GET'): sh_list,
Route('/sharded_clusters/<cluster_id>', method='GET'): info,
Route('/sharded_clusters/<cluster_id>', method='POST'): sh_command,
Route('/sharded_clusters/<cluster_id>', method='PUT'): sh_create_by_id,
Route('/sharded_clusters/<cluster_id>', method='DELETE'): sh_del,
Route('/sharded_clusters/<cluster_id>/shards', method='POST'): shard_add,
Route('/sharded_clusters/<cluster_id>/shards', method='GET'): shards,
Route('/sharded_clusters/<cluster_id>/configsvrs',
method='GET'): configsvrs,
Route('/sharded_clusters/<cluster_id>/routers', method='GET'): routers,
Route('/sharded_clusters/<cluster_id>/routers', method='POST'): router_add,
Route('/sharded_clusters/<cluster_id>/routers/<router_id>',
method='DELETE'): router_del,
Route('/sharded_clusters/<cluster_id>/shards/<shard_id>',
method='GET'): shard_info,
Route('/sharded_clusters/<cluster_id>/shards/<shard_id>',
method='DELETE'): shard_del
}
setup_versioned_routes(ROUTES, version='v1')
# Assume v1 if no version is specified.
setup_versioned_routes(ROUTES)
if __name__ == '__main__':
rs = ShardedClusters()
rs.set_settings()
run(host='localhost', port=8889, debug=True, reloader=False)
def setUp(self):
self.sh = ShardedClusters()
set_releases({"default-release": os.environ.get('MONGOBIN', '')},
'default-release')
PortPool().change_range()
def setUp(self):
self.sh = ShardedClusters()
set_releases({"default-release": os.environ.get('MONGOBIN', '')},
'default-release')
PortPool().change_range()
def sh_del(cluster_id):
logger.debug("sh_del({cluster_id})".format(**locals()))
if cluster_id not in ShardedClusters():
return send_result(404)
result = ShardedClusters().remove(cluster_id)
return send_result(204, result)
def set_releases(releases=None, default_release=None):
Servers().set_settings(releases, default_release)
ReplicaSets().set_settings(releases, default_release)
ShardedClusters().set_settings(releases, default_release)
def shard_del(cluster_id, shard_id):
logger.debug("member_del({cluster_id}), {shard_id}".format(**locals()))
if cluster_id not in ShardedClusters():
return send_result(404)
result = ShardedClusters().member_del(cluster_id, shard_id)
return send_result(204, result)
def router_del(cluster_id, router_id):
logger.debug("router_del({cluster_id}), {router_id}".format(**locals()))
if cluster_id not in ShardedClusters():
return send_result(404)
result = ShardedClusters().router_del(cluster_id, router_id)
return send_result(204, result)
def cleanup_storage(*args):
"""Clean up processes after SIGTERM or SIGINT is received."""
ShardedClusters().cleanup()
ReplicaSets().cleanup()
Servers().cleanup()
sys.exit(0)
sh_create_by_id,
Route('/sharded_clusters/<cluster_id>', method='DELETE'):
sh_del,
Route('/sharded_clusters/<cluster_id>/shards', method='POST'):
shard_add,
Route('/sharded_clusters/<cluster_id>/shards', method='GET'):
shards,
Route('/sharded_clusters/<cluster_id>/configsvrs', method='GET'):
configsvrs,
Route('/sharded_clusters/<cluster_id>/routers', method='GET'):
routers,
Route('/sharded_clusters/<cluster_id>/routers', method='POST'):
router_add,
Route('/sharded_clusters/<cluster_id>/routers/<router_id>',
method='DELETE'):
router_del,
Route('/sharded_clusters/<cluster_id>/shards/<shard_id>', method='GET'):
shard_info,
Route('/sharded_clusters/<cluster_id>/shards/<shard_id>', method='DELETE'):
shard_del
}
setup_versioned_routes(ROUTES, version='v1')
# Assume v1 if no version is specified.
setup_versioned_routes(ROUTES)
if __name__ == '__main__':
rs = ShardedClusters()
rs.set_settings()
run(host='localhost', port=8889, debug=True, reloader=False)
