def test_rollback(self):
"""Tests rollback. We force a rollback by inserting one doc, killing
primary, adding another doc, killing the new primary, and
restarting both the servers.
"""
primary_conn = Connection('localhost', int(PORTS_ONE['PRIMARY']))
conn['test']['test'].insert({'name': 'paul'}, safe=True)
while conn['test']['test'].find({'name': 'paul'}).count() != 1:
time.sleep(1)
while len(s.search('*:*')) != 1:
time.sleep(1)
killMongoProc('localhost', PORTS_ONE['PRIMARY'])
new_primary_conn = Connection('localhost', int(PORTS_ONE['SECONDARY']))
admin_db = new_primary_conn['admin']
while admin_db.command("isMaster")['ismaster'] is False:
time.sleep(1)
time.sleep(5)
count = 0
while True:
try:
a = conn['test']['test'].insert({'name': 'pauline'}, safe=True)
break
except:
count += 1
if count > 60:
string = 'Call to insert failed too many times'
string += ' in test_rollback'
logging.error(string)
sys.exit(1)
time.sleep(1)
continue
while (len(s.search('*:*')) != 2):
time.sleep(1)
a = s.search('pauline')
b = conn['test']['test'].find_one({'name': 'pauline'})
self.assertEqual(len(a), 1)
for it in a:
self.assertEqual(it['_id'], str(b['_id']))
killMongoProc('localhost', PORTS_ONE['SECONDARY'])
startMongoProc(PORTS_ONE['PRIMARY'], "demo-repl", "/replset1a",
"/replset1a.log", None)
while primary_conn['admin'].command("isMaster")['ismaster'] is False:
time.sleep(1)
startMongoProc(PORTS_ONE['SECONDARY'], "demo-repl", "/replset1b",
"/replset1b.log", None)
time.sleep(2)
a = s.search('pauline')
self.assertEqual(len(a), 0)
a = s.search('paul')
self.assertEqual(len(a), 1)
print("PASSED TEST ROLLBACK")
def test_rollback(self):
"""Tests rollback. We force a rollback by inserting one doc, killing
primary, adding another doc, killing the new primary, and
restarting both the servers.
"""
primary_conn = Connection('localhost', int(PORTS_ONE['PRIMARY']))
conn['test']['test'].insert({'name': 'paul'}, safe=True)
while conn['test']['test'].find({'name': 'paul'}).count() != 1:
time.sleep(1)
while len(s.search('*:*')) != 1:
time.sleep(1)
killMongoProc('localhost', PORTS_ONE['PRIMARY'])
new_primary_conn = Connection('localhost', int(PORTS_ONE['SECONDARY']))
admin_db = new_primary_conn['admin']
while admin_db.command("isMaster")['ismaster'] is False:
time.sleep(1)
time.sleep(5)
count = 0
while True:
try:
a = conn['test']['test'].insert({'name': 'pauline'}, safe=True)
break
except:
count += 1
if count > 60:
string = 'Call to insert failed too many times'
string += ' in test_rollback'
logging.error(string)
sys.exit(1)
time.sleep(1)
continue
while (len(s.search('*:*')) != 2):
time.sleep(1)
a = s.search('pauline')
b = conn['test']['test'].find_one({'name': 'pauline'})
self.assertEqual(len(a), 1)
for it in a:
self.assertEqual(it['_id'], str(b['_id']))
killMongoProc('localhost', PORTS_ONE['SECONDARY'])
startMongoProc(PORTS_ONE['PRIMARY'], "demo-repl", "/replset1a",
"/replset1a.log", None)
while primary_conn['admin'].command("isMaster")['ismaster'] is False:
time.sleep(1)
startMongoProc(PORTS_ONE['SECONDARY'], "demo-repl", "/replset1b",
"/replset1b.log", None)
time.sleep(2)
a = s.search('pauline')
self.assertEqual(len(a), 0)
a = s.search('paul')
self.assertEqual(len(a), 1)
print("PASSED TEST ROLLBACK")
def test_rollback(self):
"""Tests rollback. Rollback is performed by inserting one document,
killing primary, inserting another doc, killing secondary,
and then restarting both.
"""
primary_conn = Connection('localhost', int(PORTS_ONE['PRIMARY']))
conn['test']['test'].insert({'name': 'paul'}, safe=True)
while conn['test']['test'].find({'name': 'paul'}).count() != 1:
time.sleep(1)
killMongoProc('localhost', PORTS_ONE['PRIMARY'])
new_primary_conn = Connection('localhost', int(PORTS_ONE['SECONDARY']))
admin_db = new_primary_conn['admin']
while admin_db.command("isMaster")['ismaster'] is False:
time.sleep(1)
time.sleep(5)
count = 0
while True:
try:
a = conn['test']['test'].insert({'name': 'pauline'}, safe=True)
break
except:
count += 1
if count > 60:
string = 'Call to insert failed too many times'
string += ' in test_rollback'
logging.error(string)
sys.exit(1)
time.sleep(1)
continue
while (len(doc_manager._search()) != 2):
time.sleep(1)
a = doc_manager._search()
b = conn['test']['test'].find_one({'name': 'pauline'})
self.assertEqual(len(a), 2)
for it in a:
if it['name'] == 'pauline':
self.assertEqual(it['_id'], b['_id'])
killMongoProc('localhost', PORTS_ONE['SECONDARY'])
startMongoProc(PORTS_ONE['PRIMARY'], "demo-repl", "/replset1a",
"/replset1a.log", None)
while primary_conn['admin'].command("isMaster")['ismaster'] is False:
time.sleep(1)
startMongoProc(PORTS_ONE['SECONDARY'], "demo-repl", "/replset1b",
"/replset1b.log", None)
time.sleep(2)
a = doc_manager._search()
self.assertEqual(len(a), 1)
for it in a:
self.assertEqual(it['name'], 'paul')
find_cursor = retry_until_ok(conn['test']['test'].find)
self.assertEqual(retry_until_ok(find_cursor.count), 1)
#self.assertEqual(conn['test']['test'].find().count(), 1)
print("PASSED TEST ROLLBACK")
def test_rollback(self):
"""Tests rollback. We force a rollback by adding a doc, killing the
primary, adding another doc, killing the new primary, and then
restarting both.
"""
primary_conn = Connection('localhost', int(PORTS_ONE['PRIMARY']))
conn['test']['test'].insert({'name': 'paul'}, safe=True)
while conn['test']['test'].find({'name': 'paul'}).count() != 1:
time.sleep(1)
while len(s._search()) != 1:
time.sleep(1)
killMongoProc('localhost', PORTS_ONE['PRIMARY'])
new_primary_conn = Connection('localhost', int(PORTS_ONE['SECONDARY']))
admin = new_primary_conn['admin']
while admin.command("isMaster")['ismaster'] is False:
time.sleep(1)
time.sleep(5)
count = 0
while True:
try:
a = conn['test']['test'].insert({'name': 'pauline'}, safe=True)
break
except:
time.sleep(1)
count += 1
if count >= 60:
sys.exit(1)
continue
while(len(s._search()) != 2):
time.sleep(1)
a = s._search()
b = conn['test']['test'].find_one({'name': 'pauline'})
self.assertEqual(len(a), 2)
#make sure pauling is there
for it in a:
if it['name'] == 'pauline':
self.assertEqual(it['_id'], str(b['_id']))
killMongoProc('localhost', PORTS_ONE['SECONDARY'])
startMongoProc(PORTS_ONE['PRIMARY'], "demo-repl", "/replset1a",
"/replset1a.log", None)
while primary_conn['admin'].command("isMaster")['ismaster'] is False:
time.sleep(1)
startMongoProc(PORTS_ONE['SECONDARY'], "demo-repl", "/replset1b",
"/replset1b.log", None)
time.sleep(2)
a = s._search()
self.assertEqual(len(a), 1)
for it in a:
self.assertEqual(it['name'], 'paul')
find_cursor = retry_until_ok(conn['test']['test'].find)
self.assertEqual(retry_until_ok(find_cursor.count), 1)
print("PASSED TEST ROLLBACK")
def test_rollback(self):
"""Tests rollback. Rollback is performed by inserting one document,
killing primary, inserting another doc, killing secondary,
and then restarting both.
"""
primary_conn = Connection('localhost', int(PORTS_ONE['PRIMARY']))
conn['test']['test'].insert({'name': 'paul'}, safe=True)
while conn['test']['test'].find({'name': 'paul'}).count() != 1:
time.sleep(1)
killMongoProc('localhost', PORTS_ONE['PRIMARY'])
new_primary_conn = Connection('localhost', int(PORTS_ONE['SECONDARY']))
admin_db = new_primary_conn['admin']
while admin_db.command("isMaster")['ismaster'] is False:
time.sleep(1)
time.sleep(5)
count = 0
while True:
try:
a = conn['test']['test'].insert({'name': 'pauline'}, safe=True)
break
except:
count += 1
if count > 60:
string = 'Call to insert failed too many times'
string += ' in test_rollback'
logging.error(string)
sys.exit(1)
time.sleep(1)
continue
while (len(doc_manager._search()) != 2):
time.sleep(1)
a = doc_manager._search()
b = conn['test']['test'].find_one({'name': 'pauline'})
self.assertEqual(len(a), 2)
for it in a:
if it['name'] == 'pauline':
self.assertEqual(it['_id'], b['_id'])
killMongoProc('localhost', PORTS_ONE['SECONDARY'])
startMongoProc(PORTS_ONE['PRIMARY'], "demo-repl", "/replset1a",
"/replset1a.log", None)
while primary_conn['admin'].command("isMaster")['ismaster'] is False:
time.sleep(1)
startMongoProc(PORTS_ONE['SECONDARY'], "demo-repl", "/replset1b",
"/replset1b.log", None)
time.sleep(2)
a = doc_manager._search()
self.assertEqual(len(a), 1)
for it in a:
self.assertEqual(it['name'], 'paul')
find_cursor = retry_until_ok(conn['test']['test'].find)
self.assertEqual(retry_until_ok(find_cursor.count), 1)
#self.assertEqual(conn['test']['test'].find().count(), 1)
print("PASSED TEST ROLLBACK")
def test_rollback(self):
"""Tests rollback. We force a rollback by adding a doc, killing the
primary, adding another doc, killing the new primary, and then
restarting both.
"""
primary_conn = Connection('localhost', int(PORTS_ONE['PRIMARY']))
conn['test']['test'].insert({'name': 'paul'}, safe=True)
while conn['test']['test'].find({'name': 'paul'}).count() != 1:
time.sleep(1)
while len(doc_manager._search()) != 1:
time.sleep(1)
killMongoProc('localhost', PORTS_ONE['PRIMARY'])
new_primary_conn = Connection('localhost', int(PORTS_ONE['SECONDARY']))
admin = new_primary_conn['admin']
while admin.command("isMaster")['ismaster'] is False:
time.sleep(1)
time.sleep(5)
count = 0
while True:
try:
a = conn['test']['test'].insert({'name': 'pauline'}, safe=True)
break
except:
time.sleep(1)
count += 1
if count >= 60:
sys.exit(1)
continue
while(len(doc_manager._search()) != 2):
time.sleep(1)
a = doc_manager._search()
b = conn['test']['test'].find_one({'name': 'pauline'})
self.assertEqual(len(a), 2)
#make sure pauling is there
for it in a:
if it['name'] == 'pauline':
self.assertEqual(it['_id'], b['_id'])
killMongoProc('localhost', PORTS_ONE['SECONDARY'])
startMongoProc(PORTS_ONE['PRIMARY'], "demo-repl", "/replset1a",
"/replset1a.log", None)
while primary_conn['admin'].command("isMaster")['ismaster'] is False:
time.sleep(1)
startMongoProc(PORTS_ONE['SECONDARY'], "demo-repl", "/replset1b",
"/replset1b.log", None)
time.sleep(2)
a = doc_manager._search()
self.assertEqual(len(a), 1)
for it in a:
self.assertEqual(it['name'], 'paul')
find_cursor = retry_until_ok(conn['test']['test'].find)
self.assertEqual(retry_until_ok(find_cursor.count), 1)
print("PASSED TEST ROLLBACK")
def test_stressed_rollback(self):
"""Test stressed rollback with number of documents equal to specified
in global variable. Rollback is performed like before, but with more
documents.
"""
while len(doc_manager._search()) != 0:
time.sleep(1)
for i in range(0, NUMBER_OF_DOCS):
conn['test']['test'].insert({'name': 'Paul ' + str(i)}, safe=True)
while len(doc_manager._search()) != NUMBER_OF_DOCS:
time.sleep(1)
primary_conn = Connection('localhost', int(PORTS_ONE['PRIMARY']))
killMongoProc('localhost', PORTS_ONE['PRIMARY'])
new_primary_conn = Connection('localhost', int(PORTS_ONE['SECONDARY']))
admin_db = new_primary_conn['admin']
while admin_db.command("isMaster")['ismaster'] is False:
time.sleep(1)
time.sleep(5)
count = -1
while count + 1 < NUMBER_OF_DOCS:
try:
count += 1
conn['test']['test'].insert({'name': 'Pauline ' + str(count)},
safe=True)
except (OperationFailure, AutoReconnect):
time.sleep(1)
while (len(doc_manager._search()) !=
conn['test']['test'].find().count()):
time.sleep(1)
a = doc_manager._search()
i = 0
for it in a:
if 'Pauline' in it['name']:
b = conn['test']['test'].find_one({'name': it['name']})
self.assertEqual(it['_id'], b['_id'])
killMongoProc('localhost', PORTS_ONE['SECONDARY'])
startMongoProc(PORTS_ONE['PRIMARY'], "demo-repl", "/replset1a",
"/replset1a.log", None)
while primary_conn['admin'].command("isMaster")['ismaster'] is False:
time.sleep(1)
startMongoProc(PORTS_ONE['SECONDARY'], "demo-repl", "/replset1b",
"/replset1b.log", None)
while (len(doc_manager._search()) != NUMBER_OF_DOCS):
time.sleep(5)
a = doc_manager._search()
self.assertEqual(len(a), NUMBER_OF_DOCS)
for it in a:
self.assertTrue('Paul' in it['name'])
find_cursor = retry_until_ok(conn['test']['test'].find)
self.assertEqual(retry_until_ok(find_cursor.count), NUMBER_OF_DOCS)
print("PASSED TEST STRESSED ROLBACK")
def test_stressed_rollback(self):
"""Test stressed rollback with number of documents equal to specified
in global variable. Strategy for rollback is the same as before.
"""
while len(s._search()) != 0:
time.sleep(1)
for i in range(0, NUMBER_OF_DOCS):
conn['test']['test'].insert({'name': 'Paul ' + str(i)}, safe=True)
while len(s._search()) != NUMBER_OF_DOCS:
time.sleep(1)
primary_conn = Connection('localhost', int(PORTS_ONE['PRIMARY']))
killMongoProc('localhost', PORTS_ONE['PRIMARY'])
new_primary_conn = Connection('localhost', int(PORTS_ONE['SECONDARY']))
admin = new_primary_conn['admin']
while admin.command("isMaster")['ismaster'] is False:
time.sleep(1)
time.sleep(5)
count = -1
while count + 1 < NUMBER_OF_DOCS:
try:
count += 1
conn['test']['test'].insert({'name': 'Pauline ' + str(count)},
safe=True)
except (OperationFailure, AutoReconnect):
time.sleep(1)
while (len(s._search()) != conn['test']['test'].find().count()):
time.sleep(1)
a = s._search()
for it in a:
if 'Pauline' in it['name']:
b = conn['test']['test'].find_one({'name': it['name']})
self.assertEqual(it['_id'], str(b['_id']))
killMongoProc('localhost', PORTS_ONE['SECONDARY'])
startMongoProc(PORTS_ONE['PRIMARY'], "demo-repl", "/replset1a",
"/replset1a.log", None)
while primary_conn['admin'].command("isMaster")['ismaster'] is False:
time.sleep(1)
time.sleep(1)
startMongoProc(PORTS_ONE['SECONDARY'], "demo-repl", "/replset1b",
"/replset1b.log", None)
while(len(s._search()) != NUMBER_OF_DOCS):
time.sleep(5)
a = s._search()
self.assertEqual(len(a), NUMBER_OF_DOCS)
for it in a:
self.assertTrue('Paul' in it['name'])
find_cursor = retry_until_ok(conn['test']['test'].find)
self.assertEqual(retry_until_ok(find_cursor.count), NUMBER_OF_DOCS)
print("PASSED TEST STRESSED ROLBACK")
def test_stressed_rollback(self):
"""Test stressed rollback with number of documents equal to specified
in global variable. The rollback is performed the same way as before
but with more docs
"""
conn['test']['test'].remove()
while len(s.search('*:*', rows=NUMBER_OF_DOCS)) != 0:
time.sleep(1)
for i in range(0, NUMBER_OF_DOCS):
conn['test']['test'].insert({'name': 'Paul ' + str(i)}, safe=True)
while len(s.search('*:*', rows=NUMBER_OF_DOCS)) != NUMBER_OF_DOCS:
time.sleep(1)
primary_conn = Connection('localhost', int(PORTS_ONE['PRIMARY']))
killMongoProc('localhost', PORTS_ONE['PRIMARY'])
new_primary_conn = Connection('localhost', int(PORTS_ONE['SECONDARY']))
admin_db = new_primary_conn['admin']
while admin_db.command("isMaster")['ismaster'] is False:
time.sleep(1)
time.sleep(5)
count = -1
while count + 1 < NUMBER_OF_DOCS:
try:
count += 1
conn['test']['test'].insert({'name': 'Pauline ' + str(count)},
safe=True)
except (OperationFailure, AutoReconnect):
time.sleep(1)
while (len(s.search('*:*', rows=NUMBER_OF_DOCS * 2)) !=
conn['test']['test'].find().count()):
time.sleep(1)
a = s.search('Pauline', rows=NUMBER_OF_DOCS * 2, sort='_id asc')
for it in a:
b = conn['test']['test'].find_one({'name': it['name']})
self.assertEqual(it['_id'], str(b['_id']))
killMongoProc('localhost', PORTS_ONE['SECONDARY'])
startMongoProc(PORTS_ONE['PRIMARY'], "demo-repl", "/replset1a",
"/replset1a.log", None)
while primary_conn['admin'].command("isMaster")['ismaster'] is False:
time.sleep(1)
startMongoProc(PORTS_ONE['SECONDARY'], "demo-repl", "/replset1b",
"/replset1b.log", None)
while (len(s.search('Pauline', rows=NUMBER_OF_DOCS * 2)) != 0):
time.sleep(15)
a = s.search('Pauline', rows=NUMBER_OF_DOCS * 2)
self.assertEqual(len(a), 0)
a = s.search('Paul', rows=NUMBER_OF_DOCS * 2)
self.assertEqual(len(a), NUMBER_OF_DOCS)
print("PASSED TEST STRESSED ROLBACK")
def test_stressed_rollback(self):
"""Test stressed rollback with number of documents equal to specified
in global variable. The rollback is performed the same way as before
but with more docs
"""
conn['test']['test'].remove()
while len(s.search('*:*', rows=NUMBER_OF_DOCS)) != 0:
time.sleep(1)
for i in range(0, NUMBER_OF_DOCS):
conn['test']['test'].insert({'name': 'Paul ' + str(i)}, safe=True)
while len(s.search('*:*', rows=NUMBER_OF_DOCS)) != NUMBER_OF_DOCS:
time.sleep(1)
primary_conn = Connection('localhost', int(PORTS_ONE['PRIMARY']))
killMongoProc('localhost', PORTS_ONE['PRIMARY'])
new_primary_conn = Connection('localhost', int(PORTS_ONE['SECONDARY']))
admin_db = new_primary_conn['admin']
while admin_db.command("isMaster")['ismaster'] is False:
time.sleep(1)
time.sleep(5)
count = -1
while count + 1 < NUMBER_OF_DOCS:
try:
count += 1
conn['test']['test'].insert({'name': 'Pauline ' + str(count)},
safe=True)
except (OperationFailure, AutoReconnect):
time.sleep(1)
while (len(s.search('*:*', rows=NUMBER_OF_DOCS * 2)) !=
conn['test']['test'].find().count()):
time.sleep(1)
a = s.search('Pauline', rows=NUMBER_OF_DOCS * 2, sort='_id asc')
for it in a:
b = conn['test']['test'].find_one({'name': it['name']})
self.assertEqual(it['_id'], str(b['_id']))
killMongoProc('localhost', PORTS_ONE['SECONDARY'])
startMongoProc(PORTS_ONE['PRIMARY'], "demo-repl", "/replset1a",
"/replset1a.log", None)
while primary_conn['admin'].command("isMaster")['ismaster'] is False:
time.sleep(1)
startMongoProc(PORTS_ONE['SECONDARY'], "demo-repl", "/replset1b",
"/replset1b.log", None)
while (len(s.search('Pauline', rows=NUMBER_OF_DOCS * 2)) != 0):
time.sleep(15)
a = s.search('Pauline', rows=NUMBER_OF_DOCS * 2)
self.assertEqual(len(a), 0)
a = s.search('Paul', rows=NUMBER_OF_DOCS * 2)
self.assertEqual(len(a), NUMBER_OF_DOCS)
print("PASSED TEST STRESSED ROLBACK")
def test_rollback(self):
"""Test rollback in oplog_manager. Assertion failure if it doesn't pass
We force a rollback by inserting a doc, killing the primary,
inserting another doc, killing the new primary, and then restarting
both.
"""
os.system('rm config.txt; touch config.txt')
start_cluster()
test_oplog, primary_conn, mongos, oplog_coll = self.get_new_oplog()
solr = DocManager()
test_oplog.doc_manager = solr
solr._delete() # equivalent to solr.delete(q='*: *')
obj1 = ObjectId('4ff74db3f646462b38000001')
mongos['test']['test'].remove({})
mongos['test']['test'].insert({'_id': obj1, 'name': 'paulie'},
safe=1)
while (mongos['test']['test'].find().count() != 1):
time.sleep(1)
cutoff_ts = test_oplog.get_last_oplog_timestamp()
obj2 = ObjectId('4ff74db3f646462b38000002')
first_doc = {'name': 'paulie', '_ts': bson_ts_to_long(cutoff_ts),
'ns': 'test.test',
'_id': obj1}
#try kill one, try restarting
killMongoProc(primary_conn.host, PORTS_ONE['PRIMARY'])
new_primary_conn = Connection('localhost', int(PORTS_ONE['SECONDARY']))
admin = new_primary_conn['admin']
while admin.command("isMaster")['ismaster'] is False:
time.sleep(1)
time.sleep(5)
count = 0
while True:
try:
current_conn = mongos['test']['test']
current_conn.insert({'_id': obj2, 'name': 'paul'}, safe=1)
break
except:
count += 1
if count > 60:
string = 'Call to insert doc failed too many times'
logging.error(string)
sys.exit(1)
time.sleep(1)
continue
while (mongos['test']['test'].find().count() != 2):
print(mongos['test']['test'].find().count())
time.sleep(1)
killMongoProc(primary_conn.host, PORTS_ONE['SECONDARY'])
startMongoProc(PORTS_ONE['PRIMARY'], "demo-repl", "/replset1a",
"/replset1a.log", None)
#wait for master to be established
while primary_conn['admin'].command("isMaster")['ismaster'] is False:
time.sleep(1)
startMongoProc(PORTS_ONE['SECONDARY'], "demo-repl", "/replset1b",
"/replset1b.log", None)
#wait for secondary to be established
admin = new_primary_conn['admin']
while admin.command("replSetGetStatus")['myState'] != 2:
time.sleep(1)
while retry_until_ok(mongos['test']['test'].find().count) != 1:
time.sleep(1)
self.assertEqual(str(new_primary_conn.port), PORTS_ONE['SECONDARY'])
self.assertEqual(str(primary_conn.port), PORTS_ONE['PRIMARY'])
last_ts = test_oplog.get_last_oplog_timestamp()
second_doc = {'name': 'paul', '_ts': bson_ts_to_long(last_ts),
'ns': 'test.test', '_id': obj2}
test_oplog.doc_manager.upsert(first_doc)
test_oplog.doc_manager.upsert(second_doc)
test_oplog.rollback()
test_oplog.doc_manager.commit()
results = solr._search()
assert(len(results) == 1)
results_doc = results[0]
self.assertEqual(results_doc['name'], 'paulie')
self.assertTrue(results_doc['_ts'] <= bson_ts_to_long(cutoff_ts))
#test_oplog.join()
print("PASSED TEST ROLLBACK")
def test_rollback(self):
"""Test rollback in oplog_manager. Assertion failure if it doesn't pass
We force a rollback by inserting a doc, killing the primary,
inserting another doc, killing the new primary, and then restarting
both.
"""
os.system('rm config.txt; touch config.txt')
start_cluster()
test_oplog, primary_conn, mongos, oplog_coll = self.get_new_oplog()
solr = DocManager()
test_oplog.doc_manager = solr
solr._delete() # equivalent to solr.delete(q='*: *')
obj1 = ObjectId('4ff74db3f646462b38000001')
mongos['test']['test'].remove({})
mongos['test']['test'].insert({'_id': obj1, 'name': 'paulie'}, safe=1)
while (mongos['test']['test'].find().count() != 1):
time.sleep(1)
cutoff_ts = test_oplog.get_last_oplog_timestamp()
obj2 = ObjectId('4ff74db3f646462b38000002')
first_doc = {
'name': 'paulie',
'_ts': bson_ts_to_long(cutoff_ts),
'ns': 'test.test',
'_id': obj1
}
#try kill one, try restarting
killMongoProc(primary_conn.host, PORTS_ONE['PRIMARY'])
new_primary_conn = Connection('localhost', int(PORTS_ONE['SECONDARY']))
admin = new_primary_conn['admin']
while admin.command("isMaster")['ismaster'] is False:
time.sleep(1)
time.sleep(5)
count = 0
while True:
try:
current_conn = mongos['test']['test']
current_conn.insert({'_id': obj2, 'name': 'paul'}, safe=1)
break
except:
count += 1
if count > 60:
string = 'Call to insert doc failed too many times'
logging.error(string)
sys.exit(1)
time.sleep(1)
continue
while (mongos['test']['test'].find().count() != 2):
print(mongos['test']['test'].find().count())
time.sleep(1)
killMongoProc(primary_conn.host, PORTS_ONE['SECONDARY'])
startMongoProc(PORTS_ONE['PRIMARY'], "demo-repl", "/replset1a",
"/replset1a.log", None)
#wait for master to be established
while primary_conn['admin'].command("isMaster")['ismaster'] is False:
time.sleep(1)
startMongoProc(PORTS_ONE['SECONDARY'], "demo-repl", "/replset1b",
"/replset1b.log", None)
#wait for secondary to be established
admin = new_primary_conn['admin']
while admin.command("replSetGetStatus")['myState'] != 2:
time.sleep(1)
while retry_until_ok(mongos['test']['test'].find().count) != 1:
time.sleep(1)
self.assertEqual(str(new_primary_conn.port), PORTS_ONE['SECONDARY'])
self.assertEqual(str(primary_conn.port), PORTS_ONE['PRIMARY'])
last_ts = test_oplog.get_last_oplog_timestamp()
second_doc = {
'name': 'paul',
'_ts': bson_ts_to_long(last_ts),
'ns': 'test.test',
'_id': obj2
}
test_oplog.doc_manager.upsert(first_doc)
test_oplog.doc_manager.upsert(second_doc)
test_oplog.rollback()
test_oplog.doc_manager.commit()
results = solr._search()
assert (len(results) == 1)
results_doc = results[0]
self.assertEqual(results_doc['name'], 'paulie')
self.assertTrue(results_doc['_ts'] <= bson_ts_to_long(cutoff_ts))
#test_oplog.join()
print("PASSED TEST ROLLBACK")
