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)