def test_existingDatabase(self):
domain = None
database = None
try:
domain = Domain(self.host, DOMAIN_USER, DOMAIN_PASSWORD)
peer = domain.entry_peer
sm = peer.start_storage_manager(TEST_DB_NAME,
gen_archive_path(),
True,
wait_seconds=10)
te = peer.start_transaction_engine(
TEST_DB_NAME, [('--dba-user', DBA_USER),
('--dba-password', DBA_PASSWORD)],
wait_seconds=10)
database = domain.get_database(TEST_DB_NAME)
self.assertIsNotNone(database)
domain.disconnect()
time.sleep(1)
domain = Domain(self.host, DOMAIN_USER, DOMAIN_PASSWORD)
database = domain.get_database(TEST_DB_NAME)
self.assertIsNotNone(database)
self.assertEqual(len(database.processes), 2)
finally:
self._cleanup(domain)
def test_shutdownDomain(self):
domain = None
database = None
try:
domain = Domain(self.host, DOMAIN_USER, DOMAIN_PASSWORD)
num_dbs_before = len(domain.databases)
peer = domain.entry_peer
sm = peer.start_storage_manager(TEST_DB_NAME,
gen_archive_path(),
True,
wait_seconds=10)
te = peer.start_transaction_engine(
TEST_DB_NAME, [('--dba-user', DBA_USER),
('--dba-password', DBA_PASSWORD)],
wait_seconds=10)
database = domain.get_database(TEST_DB_NAME)
self.assertIsNotNone(database)
domain.shutdown()
for _ in range(0, 10):
time.sleep(1)
database = domain.get_database(TEST_DB_NAME)
if database is None:
break
database = domain.get_database(TEST_DB_NAME)
self.assertIsNone(database)
finally:
self._cleanup(domain)
def test_existingDatabase(self):
domain = None
database = None
try:
domain = Domain(self.host, DOMAIN_USER, DOMAIN_PASSWORD)
peer = domain.entry_peer
sm = peer.start_storage_manager(TEST_DB_NAME, gen_archive_path(), True, wait_seconds=10)
te = peer.start_transaction_engine(TEST_DB_NAME,
[('--dba-user', DBA_USER), ('--dba-password', DBA_PASSWORD)],
wait_seconds=10)
database = domain.get_database(TEST_DB_NAME)
self.assertIsNotNone(database)
domain.disconnect()
time.sleep(1)
domain = Domain(self.host, DOMAIN_USER, DOMAIN_PASSWORD)
database = domain.get_database(TEST_DB_NAME)
self.assertIsNotNone(database)
self.assertEqual(len(database.processes), 2)
finally:
self._cleanup(domain)
def test_shutdownDomain(self):
domain = None
database = None
try:
domain = Domain(self.host, DOMAIN_USER, DOMAIN_PASSWORD)
num_dbs_before = len(domain.databases)
peer = domain.entry_peer
sm = peer.start_storage_manager(TEST_DB_NAME, gen_archive_path(), True, wait_seconds=10)
te = peer.start_transaction_engine(TEST_DB_NAME,
[('--dba-user', DBA_USER), ('--dba-password', DBA_PASSWORD)],
wait_seconds=10)
database = domain.get_database(TEST_DB_NAME)
self.assertIsNotNone(database)
domain.shutdown()
for _ in range(0, 10):
time.sleep(1)
database = domain.get_database(TEST_DB_NAME)
if database is None:
break
database = domain.get_database(TEST_DB_NAME)
self.assertIsNone(database)
finally:
self._cleanup(domain)
def test_twoDatabase(self):
domain = None
database1 = None
database2 = None
try:
domain = Domain(self.host, DOMAIN_USER, DOMAIN_PASSWORD)
peer = domain.entry_peer
sm1 = peer.start_storage_manager(TEST_DB_NAME,
gen_archive_path(),
True,
wait_seconds=10)
te1 = peer.start_transaction_engine(
TEST_DB_NAME, [('--dba-user', DBA_USER),
('--dba-password', DBA_PASSWORD)],
wait_seconds=10)
database1 = domain.get_database(TEST_DB_NAME)
self.assertIsNotNone(database1)
sm2 = peer.start_storage_manager(TEST_DB_NAME2,
gen_archive_path(),
True,
wait_seconds=10)
te2 = peer.start_transaction_engine(
TEST_DB_NAME2, [('--dba-user', DBA_USER),
('--dba-password', DBA_PASSWORD)],
wait_seconds=10)
database2 = domain.get_database(TEST_DB_NAME2)
self.assertIsNotNone(database2)
self.assertNotEqual(database1, database2)
self.assertIn(sm1, peer.get_local_processes())
self.assertIn(te1, peer.get_local_processes())
self.assertIn(sm2, peer.get_local_processes())
self.assertIn(te2, peer.get_local_processes())
self.assertIn(sm1, peer.get_local_processes(database1.name))
self.assertIn(te1, peer.get_local_processes(database1.name))
self.assertIn(sm2, peer.get_local_processes(database2.name))
self.assertIn(te2, peer.get_local_processes(database2.name))
self.assertNotIn(sm1, peer.get_local_processes(database2.name))
self.assertNotIn(te1, peer.get_local_processes(database2.name))
self.assertNotIn(sm2, peer.get_local_processes(database1.name))
self.assertNotIn(te2, peer.get_local_processes(database1.name))
finally:
self._cleanup(domain)
def test_killProcess(self):
domain = None
database = None
try:
domain = Domain(self.host, DOMAIN_USER, DOMAIN_PASSWORD)
num_dbs_before = len(domain.databases)
peer = domain.entry_peer
sm = peer.start_storage_manager(TEST_DB_NAME,
gen_archive_path(),
True,
wait_seconds=10)
te = peer.start_transaction_engine(
TEST_DB_NAME, [('--dba-user', DBA_USER),
('--dba-password', DBA_PASSWORD)],
wait_seconds=10)
new_te = peer.start_transaction_engine(TEST_DB_NAME,
wait_seconds=10)
database = domain.get_database(TEST_DB_NAME)
self.assertEqual(len(database.processes), 3)
new_te.kill()
time.sleep(1)
self.assertEqual(len(database.processes), 2)
finally:
self._cleanup(domain)
def test_shutdownProcess(self):
domain = None
database = None
try:
domain = Domain(BROKER_HOST, DOMAIN_USER, DOMAIN_PASSWORD)
num_dbs_before = len(domain.databases)
peer = domain.entry_peer
sm = peer.start_storage_manager(TEST_DB_NAME, gen_archive_path(), True, wait_seconds=10)
te = peer.start_transaction_engine(
TEST_DB_NAME, [("--dba-user", DBA_USER), ("--dba-password", DBA_PASSWORD)], wait_seconds=10
)
new_te = peer.start_transaction_engine(TEST_DB_NAME, wait_seconds=10)
database = domain.get_database(TEST_DB_NAME)
self.assertEqual(len(database.processes), 3)
new_te.shutdown()
for _ in xrange(0, 10):
time.sleep(1)
if len(database.processes) == 2:
break
self.assertEqual(len(database.processes), 2)
finally:
self._cleanup(domain)
def test_addProcess(self):
domain = None
database = None
try:
domain = Domain(BROKER_HOST, DOMAIN_USER, DOMAIN_PASSWORD)
num_dbs_before = len(domain.databases)
peer = domain.entry_peer
sm = peer.start_storage_manager(TEST_DB_NAME,
gen_archive_path(),
True,
wait_seconds=10)
te = peer.start_transaction_engine(
TEST_DB_NAME, [('--dba-user', DBA_USER),
('--dba-password', DBA_PASSWORD)],
wait_seconds=10)
database = domain.get_database(TEST_DB_NAME)
self.assertEqual(len(database.processes), 2)
new_te = peer.start_transaction_engine(TEST_DB_NAME,
wait_seconds=10)
self.assertTrue(new_te.wait_for_status('RUNNING', 10))
self.assertEqual(len(database.processes), 3)
finally:
self._cleanup(domain)
def test_startDatabase(self):
"""Starts a TE and SM for a new database on a single host"""
domain = None
database = None
try:
domain = Domain(self.host, DOMAIN_USER, DOMAIN_PASSWORD)
num_dbs_before = len(domain.databases)
peer = domain.entry_peer
sm = peer.start_storage_manager(TEST_DB_NAME,
gen_archive_path(),
True,
wait_seconds=10)
self.assertIsNotNone(sm)
self.assertIs(sm.peer, peer)
self.assertIsNotNone(sm.address)
self.assertIsNotNone(sm.port)
self.assertIsNotNone(sm.pid)
self.assertIsNotNone(sm.hostname)
self.assertIsNotNone(sm.version)
self.assertEqual(len(domain.databases), num_dbs_before + 1)
self.assertIn(sm, peer.get_local_processes())
self.assertFalse(sm.is_transactional)
database = domain.get_database(TEST_DB_NAME)
self.assertIsNotNone(database)
self.assertIn(database, domain.databases)
self.assertIs(database.domain, domain)
self.assertEqual(database.name, TEST_DB_NAME)
self.assertEqual(len(database.processes), 1)
self.assertIn(sm, database.processes)
te = peer.start_transaction_engine(
TEST_DB_NAME, [('--dba-user', DBA_USER),
('--dba-password', DBA_PASSWORD)],
wait_seconds=10)
self.assertIsNotNone(te)
self.assertIs(te.peer, peer)
self.assertIsNotNone(te.address)
self.assertIsNotNone(te.port)
self.assertIsNotNone(te.pid)
self.assertIsNotNone(te.hostname)
self.assertIsNotNone(te.version)
self.assertEqual(len(domain.databases), num_dbs_before + 1)
self.assertIn(te, peer.get_local_processes())
self.assertTrue(te.is_transactional)
self.assertEqual(len(database.processes), 2)
self.assertIn(te, database.processes)
self.assertEqual(sm.version, te.version)
self.assertIs(sm.database, database)
self.assertIs(te.database, database)
finally:
self._cleanup(domain)
def test_startDatabase(self):
"""Starts a TE and SM for a new database on a single host"""
domain = None
database = None
try:
domain = Domain(self.host, DOMAIN_USER, DOMAIN_PASSWORD)
num_dbs_before = len(domain.databases)
peer = domain.entry_peer
sm = peer.start_storage_manager(TEST_DB_NAME, gen_archive_path(), True, wait_seconds=10)
self.assertIsNotNone(sm)
self.assertIs(sm.peer, peer)
self.assertIsNotNone(sm.address)
self.assertIsNotNone(sm.port)
self.assertIsNotNone(sm.pid)
self.assertIsNotNone(sm.hostname)
self.assertIsNotNone(sm.version)
self.assertEqual(len(domain.databases), num_dbs_before + 1)
self.assertIn(sm, peer.get_local_processes())
self.assertFalse(sm.is_transactional)
database = domain.get_database(TEST_DB_NAME)
self.assertIsNotNone(database)
self.assertIn(database, domain.databases)
self.assertIs(database.domain, domain)
self.assertEqual(database.name, TEST_DB_NAME)
self.assertEqual(len(database.processes), 1)
self.assertIn(sm, database.processes)
te = peer.start_transaction_engine(TEST_DB_NAME,
[('--dba-user', DBA_USER), ('--dba-password', DBA_PASSWORD)],
wait_seconds=10)
self.assertIsNotNone(te)
self.assertIs(te.peer, peer)
self.assertIsNotNone(te.address)
self.assertIsNotNone(te.port)
self.assertIsNotNone(te.pid)
self.assertIsNotNone(te.hostname)
self.assertIsNotNone(te.version)
self.assertEqual(len(domain.databases), num_dbs_before + 1)
self.assertIn(te, peer.get_local_processes())
self.assertTrue(te.is_transactional)
self.assertEqual(len(database.processes), 2)
self.assertIn(te, database.processes)
self.assertEqual(sm.version, te.version)
self.assertIs(sm.database, database)
self.assertIs(te.database, database)
finally:
self._cleanup(domain)
def test_twoDatabase(self):
domain = None
database1 = None
database2 = None
try:
domain = Domain(self.host, DOMAIN_USER, DOMAIN_PASSWORD)
peer = domain.entry_peer
sm1 = peer.start_storage_manager(TEST_DB_NAME, gen_archive_path(), True, wait_seconds=10)
te1 = peer.start_transaction_engine(TEST_DB_NAME,
[('--dba-user', DBA_USER), ('--dba-password', DBA_PASSWORD)],
wait_seconds=10)
database1 = domain.get_database(TEST_DB_NAME)
self.assertIsNotNone(database1)
sm2 = peer.start_storage_manager(TEST_DB_NAME2, gen_archive_path(), True, wait_seconds=10)
te2 = peer.start_transaction_engine(TEST_DB_NAME2,
[('--dba-user', DBA_USER), ('--dba-password', DBA_PASSWORD)],
wait_seconds=10)
database2 = domain.get_database(TEST_DB_NAME2)
self.assertIsNotNone(database2)
self.assertNotEqual(database1, database2)
self.assertIn(sm1, peer.get_local_processes())
self.assertIn(te1, peer.get_local_processes())
self.assertIn(sm2, peer.get_local_processes())
self.assertIn(te2, peer.get_local_processes())
self.assertIn(sm1, peer.get_local_processes(database1.name))
self.assertIn(te1, peer.get_local_processes(database1.name))
self.assertIn(sm2, peer.get_local_processes(database2.name))
self.assertIn(te2, peer.get_local_processes(database2.name))
self.assertNotIn(sm1, peer.get_local_processes(database2.name))
self.assertNotIn(te1, peer.get_local_processes(database2.name))
self.assertNotIn(sm2, peer.get_local_processes(database1.name))
self.assertNotIn(te2, peer.get_local_processes(database1.name))
finally:
self._cleanup(domain)
def test_addProcess(self):
domain = None
database = None
try:
domain = Domain(self.host, DOMAIN_USER, DOMAIN_PASSWORD)
num_dbs_before = len(domain.databases)
peer = domain.entry_peer
sm = peer.start_storage_manager(TEST_DB_NAME, gen_archive_path(), True, wait_seconds=10)
te = peer.start_transaction_engine(TEST_DB_NAME, [('--dba-user', DBA_USER),('--dba-password', DBA_PASSWORD)], wait_seconds=10)
database = domain.get_database(TEST_DB_NAME)
self.assertEqual(len(database.processes), 2)
new_te = peer.start_transaction_engine(TEST_DB_NAME, wait_seconds=10)
self.assertTrue(new_te.wait_for_status('RUNNING', 10))
self.assertEqual(len(database.processes), 3)
finally:
self._cleanup(domain)
def test_listenDomain(self):
domain = None
database = None
dl = NuoTestListener()
try:
domain = Domain(self.host, DOMAIN_USER, DOMAIN_PASSWORD, dl)
peer = domain.entry_peer
self.assertIs(peer, dl.pJoined)
self.assertIsNone(dl.pLeft)
self.assertIsNone(dl.nJoined)
self.assertIsNone(dl.nLeft)
self.assertIsNone(dl.nFailed)
self.assertIsNone(dl.nStatusChanged[0])
self.assertIsNone(dl.nStatusChanged[1])
self.assertIsNone(dl.dJoined)
self.assertIsNone(dl.dLeft)
self.assertFalse(dl.c)
sm = peer.start_storage_manager(TEST_DB_NAME,
gen_archive_path(),
True,
wait_seconds=10)
i = 0
while dl.nJoined is not sm and i < 10:
time.sleep(1)
i += 1
self.assertIs(sm, dl.nJoined)
i = 0
while dl.nStatusChanged[0] is not sm and i < 10:
time.sleep(1)
i += 1
self.assertIs(sm, dl.nStatusChanged[0])
self.assertEqual("RUNNING", dl.nStatusChanged[1])
te = peer.start_transaction_engine(
TEST_DB_NAME, [('--dba-user', DBA_USER),
('--dba-password', DBA_PASSWORD)],
wait_seconds=10)
i = 0
while dl.nJoined is not te and i < 10:
time.sleep(1)
i += 1
self.assertIs(te, dl.nJoined)
i = 0
while dl.nStatusChanged[0] is not te and i < 10:
time.sleep(1)
i += 1
self.assertIs(te, dl.nStatusChanged[0])
self.assertEqual("RUNNING", dl.nStatusChanged[1])
database = domain.get_database(TEST_DB_NAME)
self.assertIs(database, dl.dJoined)
self.assertIsNone(dl.pLeft)
self.assertIsNone(dl.nLeft)
self.assertIsNone(dl.nFailed)
self.assertIsNone(dl.dLeft)
te.shutdown()
i = 0
while dl.nLeft is not te and i < 10:
time.sleep(1)
i += 1
self.assertIs(te, dl.nLeft)
self.assertIsNone(dl.dLeft)
sm.shutdown()
i = 0
while dl.nLeft is not sm and i < 10:
time.sleep(1)
i += 1
self.assertIs(sm, dl.nLeft)
self.assertIs(database, dl.dLeft)
self.assertFalse(dl.c)
domain.disconnect()
self.assertTrue(dl.c)
finally:
self._cleanup(domain)
def test_listenDomain(self):
domain = None
database = None
dl = TestListener()
try:
domain = Domain(self.host, DOMAIN_USER, DOMAIN_PASSWORD, dl)
peer = domain.entry_peer
self.assertIs(peer, dl.pJoined)
self.assertIsNone(dl.pLeft)
self.assertIsNone(dl.nJoined)
self.assertIsNone(dl.nLeft)
self.assertIsNone(dl.nFailed)
self.assertIsNone(dl.nStatusChanged[0])
self.assertIsNone(dl.nStatusChanged[1])
self.assertIsNone(dl.dJoined)
self.assertIsNone(dl.dLeft)
self.assertFalse(dl.c)
sm = peer.start_storage_manager(TEST_DB_NAME, gen_archive_path(), True, wait_seconds=10)
i = 0
while dl.nJoined is not sm and i < 10:
time.sleep(1)
i += 1
self.assertIs(sm, dl.nJoined)
i = 0
while dl.nStatusChanged[0] is not sm and i < 10:
time.sleep(1)
i += 1
self.assertIs(sm, dl.nStatusChanged[0])
self.assertEqual("RUNNING", dl.nStatusChanged[1])
te = peer.start_transaction_engine(TEST_DB_NAME,
[('--dba-user', DBA_USER), ('--dba-password', DBA_PASSWORD)],
wait_seconds=10)
i = 0
while dl.nJoined is not te and i < 10:
time.sleep(1)
i += 1
self.assertIs(te, dl.nJoined)
i = 0
while dl.nStatusChanged[0] is not te and i < 10:
time.sleep(1)
i += 1
self.assertIs(te, dl.nStatusChanged[0])
self.assertEqual("RUNNING", dl.nStatusChanged[1])
database = domain.get_database(TEST_DB_NAME)
self.assertIs(database, dl.dJoined)
self.assertIsNone(dl.pLeft)
self.assertIsNone(dl.nLeft)
self.assertIsNone(dl.nFailed)
self.assertIsNone(dl.dLeft)
te.shutdown()
i = 0
while dl.nLeft is not te and i < 10:
time.sleep(1)
i += 1
self.assertIs(te, dl.nLeft)
self.assertIsNone(dl.dLeft)
sm.shutdown()
i = 0
while dl.nLeft is not sm and i < 10:
time.sleep(1)
i += 1
self.assertIs(sm, dl.nLeft)
self.assertIs(database, dl.dLeft)
self.assertFalse(dl.c)
domain.disconnect()
self.assertTrue(dl.c)
finally:
self._cleanup(domain)
