def test_secondary_connection(self):
self.c = ReplicaSetConnection(
self.seed, replicaSet=self.name, use_greenlets=use_greenlets)
self.assertTrue(bool(len(self.c.secondaries)))
db = self.c.pymongo_test
db.test.remove({}, safe=True, w=len(self.c.secondaries))
# Force replication...
w = len(self.c.secondaries) + 1
db.test.insert({'foo': 'bar'}, safe=True, w=w)
# Test direct connection to a primary or secondary
primary_host, primary_port = replset_tools.get_primary().split(':')
primary_port = int(primary_port)
secondary_host, secondary_port = replset_tools.get_secondaries()[0].split(':')
secondary_port = int(secondary_port)
self.assertTrue(Connection(
primary_host, primary_port, use_greenlets=use_greenlets).is_primary)
self.assertTrue(Connection(
primary_host, primary_port, use_greenlets=use_greenlets,
read_preference=ReadPreference.PRIMARY_PREFERRED).is_primary)
self.assertTrue(Connection(
primary_host, primary_port, use_greenlets=use_greenlets,
read_preference=ReadPreference.SECONDARY_PREFERRED).is_primary)
self.assertTrue(Connection(
primary_host, primary_port, use_greenlets=use_greenlets,
read_preference=ReadPreference.NEAREST).is_primary)
self.assertTrue(Connection(
primary_host, primary_port, use_greenlets=use_greenlets,
read_preference=ReadPreference.SECONDARY).is_primary)
for kwargs in [
{'read_preference': ReadPreference.PRIMARY_PREFERRED},
{'read_preference': ReadPreference.SECONDARY},
{'read_preference': ReadPreference.SECONDARY_PREFERRED},
{'read_preference': ReadPreference.NEAREST},
{'slave_okay': True},
]:
conn = Connection(
secondary_host, secondary_port, use_greenlets=use_greenlets, **kwargs)
self.assertEqual(secondary_host, conn.host)
self.assertEqual(secondary_port, conn.port)
self.assertFalse(conn.is_primary)
self.assert_(conn.pymongo_test.test.find_one())
# Test direct connection to an arbiter
secondary_host = replset_tools.get_arbiters()[0]
host, port = replset_tools.arbiters()[0].split(':')
port = int(port)
conn = Connection(host, port)
self.assertEqual(host, conn.host)
self.assertEqual(port, conn.port)
def setUp(self):
members = [
# primary
{'tags': {'dc': 'ny', 'name': 'primary'}},
# secondary
{'tags': {'dc': 'la', 'name': 'secondary'}, 'priority': 0},
# other_secondary
{'tags': {'dc': 'ny', 'name': 'other_secondary'}, 'priority': 0},
]
res = replset_tools.start_replica_set(members)
self.seed, self.name = res
primary = replset_tools.get_primary()
self.primary = _partition_node(primary)
self.primary_tags = replset_tools.get_tags(primary)
# Make sure priority worked
self.assertEqual('primary', self.primary_tags['name'])
self.primary_dc = {'dc': self.primary_tags['dc']}
secondaries = replset_tools.get_secondaries()
(secondary, ) = [
s for s in secondaries
if replset_tools.get_tags(s)['name'] == 'secondary']
self.secondary = _partition_node(secondary)
self.secondary_tags = replset_tools.get_tags(secondary)
self.secondary_dc = {'dc': self.secondary_tags['dc']}
(other_secondary, ) = [
s for s in secondaries
if replset_tools.get_tags(s)['name'] == 'other_secondary']
self.other_secondary = _partition_node(other_secondary)
self.other_secondary_tags = replset_tools.get_tags(other_secondary)
self.other_secondary_dc = {'dc': self.other_secondary_tags['dc']}
self.c = ReplicaSetConnection(
self.seed, replicaSet=self.name, use_greenlets=use_greenlets)
self.db = self.c.pymongo_test
self.w = len(self.c.secondaries) + 1
self.db.test.remove({}, safe=True, w=self.w)
self.db.test.insert(
[{'foo': i} for i in xrange(10)], safe=True, w=self.w)
self.clear_ping_times()
def test_read_preference(self):
c = ReplicaSetConnection(self.seed, replicaSet=self.name)
self.assertTrue(bool(len(c.secondaries)))
db = c.pymongo_test
db.test.remove({}, safe=True, w=len(c.secondaries))
# Force replication...
w = len(c.secondaries) + 1
db.test.insert({'foo': 'bar'}, safe=True, w=w)
# Test direct connection to a secondary
host, port = replset_tools.get_secondaries()[0].split(':')
port = int(port)
conn = Connection(host, port, slave_okay=True)
self.assertEqual(host, conn.host)
self.assertEqual(port, conn.port)
self.assert_(conn.pymongo_test.test.find_one())
conn = Connection(host, port, read_preference=ReadPreference.SECONDARY)
self.assertEqual(host, conn.host)
self.assertEqual(port, conn.port)
self.assert_(conn.pymongo_test.test.find_one())
# Test direct connection to an arbiter
host = replset_tools.get_arbiters()[0]
self.assertRaises(ConnectionFailure, Connection, host)
# Test PRIMARY
for _ in xrange(10):
cursor = db.test.find()
cursor.next()
self.assertEqual(cursor._Cursor__connection_id, c.primary)
# Test SECONDARY with a secondary
db.read_preference = ReadPreference.SECONDARY
for _ in xrange(10):
cursor = db.test.find()
cursor.next()
self.assertTrue(cursor._Cursor__connection_id in c.secondaries)
# Test SECONDARY_ONLY with a secondary
db.read_preference = ReadPreference.SECONDARY_ONLY
for _ in xrange(10):
cursor = db.test.find()
cursor.next()
self.assertTrue(cursor._Cursor__connection_id in c.secondaries)
# Test SECONDARY with no secondary
killed = replset_tools.kill_all_secondaries()
self.assertTrue(bool(len(killed)))
db.read_preference = ReadPreference.SECONDARY
for _ in xrange(10):
cursor = db.test.find()
cursor.next()
self.assertEqual(cursor._Cursor__connection_id, c.primary)
# Test SECONDARY_ONLY with no secondary
db.read_preference = ReadPreference.SECONDARY_ONLY
for _ in xrange(10):
cursor = db.test.find()
self.assertRaises(AutoReconnect, cursor.next)
replset_tools.restart_members(killed)
# Test PRIMARY with no primary (should raise an exception)
db.read_preference = ReadPreference.PRIMARY
cursor = db.test.find()
cursor.next()
self.assertEqual(cursor._Cursor__connection_id, c.primary)
killed = replset_tools.kill_primary()
self.assertTrue(bool(len(killed)))
self.assertRaises(AutoReconnect, db.test.find_one)
def test_read_preference(self):
c = ReplicaSetConnection(self.seed, replicaSet=self.name)
self.assertTrue(bool(len(c.secondaries)))
db = c.pymongo_test
db.test.remove({}, safe=True, w=len(c.secondaries))
# Force replication...
w = len(c.secondaries) + 1
db.test.insert({'foo': 'bar'}, safe=True, w=w)
# Test direct connection to a secondary
host, port = replset_tools.get_secondaries()[0].split(':')
port = int(port)
conn = Connection(host, port, slave_okay=True)
self.assertEqual(host, conn.host)
self.assertEqual(port, conn.port)
self.assert_(conn.pymongo_test.test.find_one())
conn = Connection(host, port,
read_preference=ReadPreference.SECONDARY)
self.assertEqual(host, conn.host)
self.assertEqual(port, conn.port)
self.assert_(conn.pymongo_test.test.find_one())
# Test direct connection to an arbiter
host = replset_tools.get_arbiters()[0]
self.assertRaises(ConnectionFailure, Connection, host)
# Test PRIMARY
for _ in xrange(10):
cursor = db.test.find()
cursor.next()
self.assertEqual(cursor._Cursor__connection_id, c.primary)
# Test SECONDARY with a secondary
db.read_preference = ReadPreference.SECONDARY
for _ in xrange(10):
cursor = db.test.find()
cursor.next()
self.assertTrue(cursor._Cursor__connection_id in c.secondaries)
# Test SECONDARY_ONLY with a secondary
db.read_preference = ReadPreference.SECONDARY_ONLY
for _ in xrange(10):
cursor = db.test.find()
cursor.next()
self.assertTrue(cursor._Cursor__connection_id in c.secondaries)
# Test SECONDARY with no secondary
killed = replset_tools.kill_all_secondaries()
self.assertTrue(bool(len(killed)))
db.read_preference = ReadPreference.SECONDARY
for _ in xrange(10):
cursor = db.test.find()
cursor.next()
self.assertEqual(cursor._Cursor__connection_id, c.primary)
# Test SECONDARY_ONLY with no secondary
db.read_preference = ReadPreference.SECONDARY_ONLY
for _ in xrange(10):
cursor = db.test.find()
self.assertRaises(AutoReconnect, cursor.next)
replset_tools.restart_members(killed)
# Test PRIMARY with no primary (should raise an exception)
db.read_preference = ReadPreference.PRIMARY
cursor = db.test.find()
cursor.next()
self.assertEqual(cursor._Cursor__connection_id, c.primary)
killed = replset_tools.kill_primary()
self.assertTrue(bool(len(killed)))
self.assertRaises(AutoReconnect, db.test.find_one)
