def test_alive(self, done):
primary = ha_tools.get_primary()
secondary = ha_tools.get_random_secondary()
primary_cx = motor.MotorClient(primary).open_sync()
secondary_cx = motor.MotorClient(secondary).open_sync()
rsc = motor.MotorReplicaSetClient(
self.seed, replicaSet=self.name).open_sync()
loop = IOLoop.instance()
try:
yield AssertTrue(primary_cx.alive)
yield AssertTrue(secondary_cx.alive)
yield AssertTrue(rsc.alive)
ha_tools.kill_primary()
yield gen.Task(loop.add_timeout, time.time() + 0.5)
yield AssertFalse(primary_cx.alive)
yield AssertTrue(secondary_cx.alive)
# Sometimes KeyError: https://jira.mongodb.org/browse/PYTHON-467
yield AssertFalse(rsc.alive)
ha_tools.kill_members([secondary], 2)
yield gen.Task(loop.add_timeout, time.time() + 0.5)
yield AssertFalse(primary_cx.alive)
yield AssertFalse(secondary_cx.alive)
yield AssertFalse(rsc.alive)
finally:
rsc.close()
done()
def test_alive(self):
primary = ha_tools.get_primary()
secondary = ha_tools.get_random_secondary()
primary_cx = connected(
MongoClient(
primary,
serverSelectionTimeoutMS=self.server_selection_timeout)),
secondary_cx = connected(
MongoClient(
secondary,
serverSelectionTimeoutMS=self.server_selection_timeout))
rsc = connected(
MongoClient(
self.seed,
replicaSet=self.name,
serverSelectionTimeoutMS=self.server_selection_timeout))
self.assertTrue(primary_cx.alive())
self.assertTrue(secondary_cx.alive())
self.assertTrue(rsc.alive())
ha_tools.kill_primary()
time.sleep(0.5)
self.assertFalse(primary_cx.alive())
self.assertTrue(secondary_cx.alive())
self.assertFalse(rsc.alive())
ha_tools.kill_members([secondary], 2)
time.sleep(0.5)
self.assertFalse(primary_cx.alive())
self.assertFalse(secondary_cx.alive())
self.assertFalse(rsc.alive())
def test_alive(self):
primary = ha_tools.get_primary()
secondary = ha_tools.get_random_secondary()
primary_cx = MongoClient(primary, use_greenlets=use_greenlets)
secondary_cx = MongoClient(secondary, use_greenlets=use_greenlets)
rsc = MongoReplicaSetClient(self.seed,
replicaSet=self.name,
use_greenlets=use_greenlets)
try:
self.assertTrue(primary_cx.alive())
self.assertTrue(secondary_cx.alive())
self.assertTrue(rsc.alive())
ha_tools.kill_primary()
time.sleep(0.5)
self.assertFalse(primary_cx.alive())
self.assertTrue(secondary_cx.alive())
self.assertFalse(rsc.alive())
ha_tools.kill_members([secondary], 2)
time.sleep(0.5)
self.assertFalse(primary_cx.alive())
self.assertFalse(secondary_cx.alive())
self.assertFalse(rsc.alive())
finally:
rsc.close()
def test_alive(self):
primary = ha_tools.get_primary()
secondary = ha_tools.get_random_secondary()
primary_cx = yield motor.MotorClient(primary).open()
secondary_cx = yield motor.MotorClient(secondary).open()
rsc = motor.MotorReplicaSetClient(self.seed, replicaSet=self.name)
yield rsc.open()
try:
self.assertTrue((yield primary_cx.alive()))
self.assertTrue((yield secondary_cx.alive()))
self.assertTrue((yield rsc.alive()))
ha_tools.kill_primary()
yield self.pause(0.5)
self.assertFalse((yield primary_cx.alive()))
self.assertTrue((yield secondary_cx.alive()))
self.assertFalse((yield rsc.alive()))
ha_tools.kill_members([secondary], 2)
yield self.pause(0.5)
self.assertFalse((yield primary_cx.alive()))
self.assertFalse((yield secondary_cx.alive()))
self.assertFalse((yield rsc.alive()))
finally:
rsc.close()
def test_alive(self):
primary = ha_tools.get_primary()
secondary = ha_tools.get_random_secondary()
primary_cx = connected(
MongoClient(
primary,
serverSelectionTimeoutMS=self.server_selection_timeout)),
secondary_cx = connected(
MongoClient(
secondary,
serverSelectionTimeoutMS=self.server_selection_timeout))
rsc = connected(
MongoClient(
self.seed,
replicaSet=self.name,
serverSelectionTimeoutMS=self.server_selection_timeout))
self.assertTrue(primary_cx.alive())
self.assertTrue(secondary_cx.alive())
self.assertTrue(rsc.alive())
ha_tools.kill_primary()
time.sleep(0.5)
self.assertFalse(primary_cx.alive())
self.assertTrue(secondary_cx.alive())
self.assertFalse(rsc.alive())
ha_tools.kill_members([secondary], 2)
time.sleep(0.5)
self.assertFalse(primary_cx.alive())
self.assertFalse(secondary_cx.alive())
self.assertFalse(rsc.alive())
def test_alive(self):
primary = ha_tools.get_primary()
secondary = ha_tools.get_random_secondary()
primary_cx = MongoClient(primary, use_greenlets=use_greenlets)
secondary_cx = MongoClient(secondary, use_greenlets=use_greenlets)
rsc = MongoReplicaSetClient(
self.seed, replicaSet=self.name, use_greenlets=use_greenlets)
try:
self.assertTrue(primary_cx.alive())
self.assertTrue(secondary_cx.alive())
self.assertTrue(rsc.alive())
ha_tools.kill_primary()
time.sleep(0.5)
self.assertFalse(primary_cx.alive())
self.assertTrue(secondary_cx.alive())
self.assertFalse(rsc.alive())
ha_tools.kill_members([secondary], 2)
time.sleep(0.5)
self.assertFalse(primary_cx.alive())
self.assertFalse(secondary_cx.alive())
self.assertFalse(rsc.alive())
finally:
rsc.close()
def test_alive(self):
primary = ha_tools.get_primary()
secondary = ha_tools.get_random_secondary()
primary_cx = yield motor.MotorClient(primary).open()
secondary_cx = yield motor.MotorClient(secondary).open()
rsc = motor.MotorReplicaSetClient(self.seed, replicaSet=self.name)
yield rsc.open()
try:
self.assertTrue((yield primary_cx.alive()))
self.assertTrue((yield secondary_cx.alive()))
self.assertTrue((yield rsc.alive()))
ha_tools.kill_primary()
yield self.pause(0.5)
self.assertFalse((yield primary_cx.alive()))
self.assertTrue((yield secondary_cx.alive()))
self.assertFalse((yield rsc.alive()))
ha_tools.kill_members([secondary], 2)
yield self.pause(0.5)
self.assertFalse((yield primary_cx.alive()))
self.assertFalse((yield secondary_cx.alive()))
self.assertFalse((yield rsc.alive()))
finally:
rsc.close()
def test_ship_of_theseus(self):
c = MongoReplicaSetClient(
self.seed, replicaSet=self.name, use_greenlets=use_greenlets)
db = c.pymongo_test
db.test.insert({}, w=len(c.secondaries) + 1)
find_one = db.test.find_one
primary = ha_tools.get_primary()
secondary1 = ha_tools.get_random_secondary()
new_hosts = [ha_tools.add_member() for _ in range(3)]
# Wait for new members to join.
for _ in xrange(120):
if ha_tools.get_primary() and len(ha_tools.get_secondaries()) == 4:
break
sleep(1)
else:
self.fail("New secondaries didn't join")
ha_tools.kill_members([primary, secondary1], 9)
# Wait for primary.
for _ in xrange(30):
if ha_tools.get_primary() and len(ha_tools.get_secondaries()) == 2:
break
sleep(1)
else:
self.fail("No failover")
sleep(2 * MONITOR_INTERVAL)
# No error.
find_one()
find_one(read_preference=SECONDARY)
# All members down.
ha_tools.kill_members(new_hosts, 9)
self.assertRaises(
ConnectionFailure,
find_one, read_preference=SECONDARY)
ha_tools.restart_members(new_hosts)
# Should be able to reconnect to set even though original seed
# list is useless. Use SECONDARY so we don't have to wait for
# the election, merely for the client to detect members are up.
sleep(2 * MONITOR_INTERVAL)
find_one(read_preference=SECONDARY)
def test_ship_of_theseus(self, done):
loop = IOLoop.instance()
c = motor.MotorReplicaSetClient(self.seed, replicaSet=self.name)
c.open_sync()
db = c.pymongo_test
w = len(c.secondaries) + 1
db.test.insert({}, w=w)
primary = ha_tools.get_primary()
secondary1 = ha_tools.get_random_secondary()
ha_tools.add_member()
ha_tools.add_member()
ha_tools.add_member()
# Wait for new members to join
for _ in xrange(120):
if ha_tools.get_primary() and len(ha_tools.get_secondaries()) == 4:
break
yield gen.Task(loop.add_timeout, time.time() + 1)
else:
self.fail("New secondaries didn't join")
ha_tools.kill_members([primary, secondary1], 9)
# Wait for primary
for _ in xrange(30):
if ha_tools.get_primary() and len(ha_tools.get_secondaries()) == 2:
break
yield gen.Task(loop.add_timeout, time.time() + 1)
else:
self.fail("No failover")
# Ensure monitor picks up new members
yield gen.Task(loop.add_timeout, time.time() + 2 * MONITOR_INTERVAL)
try:
yield motor.Op(db.test.find_one)
except AutoReconnect:
# Might take one try to reconnect
yield gen.Task(loop.add_timeout, time.time() + 1)
# No error
yield motor.Op(db.test.find_one)
yield motor.Op(db.test.find_one, read_preference=SECONDARY)
done()
def test_request_during_failover(self):
primary = _partition_node(ha_tools.get_primary())
secondary = _partition_node(ha_tools.get_random_secondary())
self.assertTrue(self.c.auto_start_request)
self.assertTrue(self.c.in_request())
rs_state = self.c._MongoReplicaSetClient__rs_state
primary_pool = rs_state.get(primary).pool
secondary_pool = rs_state.get(secondary).pool
# Trigger start_request on primary pool
utils.assertReadFrom(self, self.c, primary, PRIMARY)
self.assertTrue(primary_pool.in_request())
# Fail over
ha_tools.kill_primary()
sleep(5)
patience_seconds = 60
for _ in range(patience_seconds):
try:
if ha_tools.ha_tools_debug:
print 'Waiting for failover'
if ha_tools.get_primary():
# We have a new primary
break
except ConnectionFailure:
pass
sleep(1)
else:
self.fail("Problem with test: No new primary after %s seconds"
% patience_seconds)
try:
# Trigger start_request on secondary_pool, which is becoming new
# primary
self.c.test.test.find_one()
except AutoReconnect:
# We've noticed the failover now
pass
# The old secondary is now primary
utils.assertReadFrom(self, self.c, secondary, PRIMARY)
self.assertTrue(self.c.in_request())
self.assertTrue(secondary_pool.in_request())
def test_request_during_failover(self):
primary = _partition_node(ha_tools.get_primary())
secondary = _partition_node(ha_tools.get_random_secondary())
self.assertTrue(self.c.auto_start_request)
self.assertTrue(self.c.in_request())
rs_state = self.c._MongoReplicaSetClient__rs_state
primary_pool = rs_state.get(primary).pool
secondary_pool = rs_state.get(secondary).pool
# Trigger start_request on primary pool
utils.assertReadFrom(self, self.c, primary, PRIMARY)
self.assertTrue(primary_pool.in_request())
# Fail over
ha_tools.kill_primary()
sleep(5)
patience_seconds = 60
for _ in range(patience_seconds):
try:
if ha_tools.ha_tools_debug:
print 'Waiting for failover'
if ha_tools.get_primary():
# We have a new primary
break
except ConnectionFailure:
pass
sleep(1)
else:
self.fail("Problem with test: No new primary after %s seconds" %
patience_seconds)
try:
# Trigger start_request on secondary_pool, which is becoming new
# primary
self.c.test.test.find_one()
except AutoReconnect:
# We've noticed the failover now
pass
# The old secondary is now primary
utils.assertReadFrom(self, self.c, secondary, PRIMARY)
self.assertTrue(self.c.in_request())
self.assertTrue(secondary_pool.in_request())
def test_ship_of_theseus(self):
c = motor.MotorReplicaSetClient(self.seed, replicaSet=self.name)
yield c.open()
db = c.motor_test
w = len(c.secondaries) + 1
db.test.insert({}, w=w)
primary = ha_tools.get_primary()
secondary1 = ha_tools.get_random_secondary()
ha_tools.add_member()
ha_tools.add_member()
ha_tools.add_member()
# Wait for new members to join
for _ in xrange(120):
if ha_tools.get_primary() and len(ha_tools.get_secondaries()) == 4:
break
yield self.pause(1)
else:
self.fail("New secondaries didn't join")
ha_tools.kill_members([primary, secondary1], 9)
# Wait for primary
for _ in xrange(30):
if ha_tools.get_primary() and len(ha_tools.get_secondaries()) == 2:
break
yield self.pause(1)
else:
self.fail("No failover")
# Ensure monitor picks up new members
yield self.pause(2 * MONITOR_INTERVAL)
try:
yield db.test.find_one()
except AutoReconnect:
# Might take one try to reconnect
yield self.pause(1)
# No error
yield db.test.find_one()
yield db.test.find_one(read_preference=SECONDARY)
def test_ship_of_theseus(self):
c = motor.MotorReplicaSetClient(self.seed, replicaSet=self.name)
yield c.open()
db = c.motor_test
w = len(c.secondaries) + 1
db.test.insert({}, w=w)
primary = ha_tools.get_primary()
secondary1 = ha_tools.get_random_secondary()
ha_tools.add_member()
ha_tools.add_member()
ha_tools.add_member()
# Wait for new members to join
for _ in xrange(120):
if ha_tools.get_primary() and len(ha_tools.get_secondaries()) == 4:
break
yield self.pause(1)
else:
self.fail("New secondaries didn't join")
ha_tools.kill_members([primary, secondary1], 9)
# Wait for primary
for _ in xrange(30):
if ha_tools.get_primary() and len(ha_tools.get_secondaries()) == 2:
break
yield self.pause(1)
else:
self.fail("No failover")
# Ensure monitor picks up new members
yield self.pause(2 * MONITOR_INTERVAL)
try:
yield db.test.find_one()
except AutoReconnect:
# Might take one try to reconnect
yield self.pause(1)
# No error
yield db.test.find_one()
yield db.test.find_one(read_preference=SECONDARY)
def test_ship_of_theseus(self):
c = MongoReplicaSetClient(
self.seed, replicaSet=self.name, use_greenlets=use_greenlets)
db = c.pymongo_test
db.test.insert({}, w=len(c.secondaries) + 1)
find_one = db.test.find_one
primary = ha_tools.get_primary()
secondary1 = ha_tools.get_random_secondary()
new_hosts = [ha_tools.add_member() for _ in range(3)]
# Wait for new members to join.
for _ in xrange(120):
if ha_tools.get_primary() and len(ha_tools.get_secondaries()) == 4:
break
sleep(1)
else:
self.fail("New secondaries didn't join")
ha_tools.kill_members([primary, secondary1], 9)
# Wait for primary.
for _ in xrange(30):
if ha_tools.get_primary() and len(ha_tools.get_secondaries()) == 2:
break
sleep(1)
else:
self.fail("No failover")
sleep(2 * MONITOR_INTERVAL)
# No error.
find_one()
find_one(read_preference=SECONDARY)
# All members down.
ha_tools.kill_members(new_hosts, 9)
self.assertRaises(
ConnectionFailure,
find_one, read_preference=SECONDARY)
ha_tools.restart_members(new_hosts)
# Should be able to reconnect to set even though original seed
# list is useless. Use SECONDARY so we don't have to wait for
# the election, merely for the client to detect members are up.
sleep(2 * MONITOR_INTERVAL)
find_one(read_preference=SECONDARY)
# Kill new members and switch back to original two members.
ha_tools.kill_members(new_hosts, 9)
self.assertRaises(
ConnectionFailure,
find_one, read_preference=SECONDARY)
ha_tools.restart_members([primary, secondary1])
# Should be able to reconnect to set again.
sleep(2 * MONITOR_INTERVAL)
find_one(read_preference=SECONDARY)
def test_ship_of_theseus(self):
c = MongoClient(
self.seed,
replicaSet=self.name,
serverSelectionTimeoutMS=self.server_selection_timeout)
db = c.get_database(
"pymongo_test",
write_concern=WriteConcern(w=len(c.secondaries) + 1))
db.test.insert_one({})
find_one = db.test.find_one
primary = ha_tools.get_primary()
secondary1 = ha_tools.get_random_secondary()
new_hosts = []
for i in range(3):
new_hosts.append(ha_tools.add_member())
# RS closes all connections after reconfig.
for j in xrange(30):
try:
if ha_tools.get_primary():
break
except (ConnectionFailure, OperationFailure):
pass
time.sleep(1)
else:
self.fail("Couldn't recover from reconfig")
# Wait for new members to join.
for _ in xrange(120):
if ha_tools.get_primary() and len(ha_tools.get_secondaries()) == 4:
break
time.sleep(1)
else:
self.fail("New secondaries didn't join")
ha_tools.kill_members([primary, secondary1], 9)
time.sleep(5)
wait_until(lambda: (ha_tools.get_primary()
and len(ha_tools.get_secondaries()) == 2),
"fail over",
timeout=30)
time.sleep(2 * self.heartbeat_frequency)
# No error.
find_one()
find_one(read_preference=SECONDARY)
# All members down.
ha_tools.kill_members(new_hosts, 9)
self.assertRaises(
ConnectionFailure,
find_one, read_preference=SECONDARY)
ha_tools.restart_members(new_hosts)
# Should be able to reconnect to set even though original seed
# list is useless. Use SECONDARY so we don't have to wait for
# the election, merely for the client to detect members are up.
time.sleep(2 * self.heartbeat_frequency)
find_one(read_preference=SECONDARY)
# Kill new members and switch back to original two members.
ha_tools.kill_members(new_hosts, 9)
self.assertRaises(
ConnectionFailure,
find_one, read_preference=SECONDARY)
ha_tools.restart_members([primary, secondary1])
# Wait for members to figure out they're secondaries.
wait_until(lambda: len(ha_tools.get_secondaries()) == 2,
"detect two secondaries",
timeout=30)
# Should be able to reconnect to set again.
time.sleep(2 * self.heartbeat_frequency)
find_one(read_preference=SECONDARY)
def test_ship_of_theseus(self):
c = MongoClient(
self.seed,
replicaSet=self.name,
serverSelectionTimeoutMS=self.server_selection_timeout)
db = c.get_database(
"pymongo_test",
write_concern=WriteConcern(w=len(c.secondaries) + 1))
db.test.insert_one({})
find_one = db.test.find_one
primary = ha_tools.get_primary()
secondary1 = ha_tools.get_random_secondary()
new_hosts = []
for i in range(3):
new_hosts.append(ha_tools.add_member())
# RS closes all connections after reconfig.
for j in xrange(30):
try:
if ha_tools.get_primary():
break
except (ConnectionFailure, OperationFailure):
pass
time.sleep(1)
else:
self.fail("Couldn't recover from reconfig")
# Wait for new members to join.
for _ in xrange(120):
if ha_tools.get_primary() and len(ha_tools.get_secondaries()) == 4:
break
time.sleep(1)
else:
self.fail("New secondaries didn't join")
ha_tools.kill_members([primary, secondary1], 9)
time.sleep(5)
wait_until(lambda: (ha_tools.get_primary()
and len(ha_tools.get_secondaries()) == 2),
"fail over",
timeout=30)
time.sleep(2 * self.heartbeat_frequency)
# No error.
find_one()
find_one(read_preference=SECONDARY)
# All members down.
ha_tools.kill_members(new_hosts, 9)
self.assertRaises(
ConnectionFailure,
find_one, read_preference=SECONDARY)
ha_tools.restart_members(new_hosts)
# Should be able to reconnect to set even though original seed
# list is useless. Use SECONDARY so we don't have to wait for
# the election, merely for the client to detect members are up.
time.sleep(2 * self.heartbeat_frequency)
find_one(read_preference=SECONDARY)
# Kill new members and switch back to original two members.
ha_tools.kill_members(new_hosts, 9)
self.assertRaises(
ConnectionFailure,
find_one, read_preference=SECONDARY)
ha_tools.restart_members([primary, secondary1])
# Wait for members to figure out they're secondaries.
wait_until(lambda: len(ha_tools.get_secondaries()) == 2,
"detect two secondaries",
timeout=30)
# Should be able to reconnect to set again.
time.sleep(2 * self.heartbeat_frequency)
find_one(read_preference=SECONDARY)
def test_ship_of_theseus(self):
c = MongoReplicaSetClient(
self.seed, replicaSet=self.name, use_greenlets=use_greenlets)
db = c.pymongo_test
db.test.insert({}, w=len(c.secondaries) + 1)
find_one = db.test.find_one
primary = ha_tools.get_primary()
secondary1 = ha_tools.get_random_secondary()
new_hosts = []
for i in range(3):
new_hosts.append(ha_tools.add_member())
# RS closes all connections after reconfig.
for j in xrange(30):
try:
if ha_tools.get_primary():
break
except (ConnectionFailure, OperationFailure):
pass
sleep(1)
else:
self.fail("Couldn't recover from reconfig")
# Wait for new members to join.
for _ in xrange(120):
if ha_tools.get_primary() and len(ha_tools.get_secondaries()) == 4:
break
sleep(1)
else:
self.fail("New secondaries didn't join")
ha_tools.kill_members([primary, secondary1], 9)
sleep(5)
# Wait for primary.
for _ in xrange(30):
if ha_tools.get_primary() and len(ha_tools.get_secondaries()) == 2:
break
sleep(1)
else:
self.fail("No failover")
sleep(2 * MONITOR_INTERVAL)
# No error.
find_one()
find_one(read_preference=SECONDARY)
# All members down.
ha_tools.kill_members(new_hosts, 9)
self.assertRaises(
ConnectionFailure,
find_one, read_preference=SECONDARY)
ha_tools.restart_members(new_hosts)
# Should be able to reconnect to set even though original seed
# list is useless. Use SECONDARY so we don't have to wait for
# the election, merely for the client to detect members are up.
sleep(2 * MONITOR_INTERVAL)
find_one(read_preference=SECONDARY)
# Kill new members and switch back to original two members.
ha_tools.kill_members(new_hosts, 9)
self.assertRaises(
ConnectionFailure,
find_one, read_preference=SECONDARY)
ha_tools.restart_members([primary, secondary1])
# Wait for members to figure out they're secondaries.
for _ in xrange(30):
try:
if len(ha_tools.get_secondaries()) == 2:
break
except ConnectionFailure:
pass
sleep(1)
else:
self.fail("Original members didn't become secondaries")
# Should be able to reconnect to set again.
sleep(2 * MONITOR_INTERVAL)
find_one(read_preference=SECONDARY)
