def test_shutdownProcess(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.shutdown() for _ in range(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_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_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_find_peer(self): domain = None try: domain = Domain(self.host, DOMAIN_USER, DOMAIN_PASSWORD) found_peer = domain.find_peer('localhost') self.assertIsNotNone(found_peer) self.assertIs(domain.entry_peer, found_peer) found_peer = domain.find_peer('localhost', os.environ['NUODB_PORT'] if 'NUODB_PORT' in os.environ else domain.entry_peer.port) self.assertIsNotNone(found_peer) self.assertIs(domain.entry_peer, found_peer) finally: self._cleanup(domain)
def test_find_peer(self): domain = None try: domain = Domain(self.host, DOMAIN_USER, DOMAIN_PASSWORD) found_peer = domain.find_peer('localhost') self.assertIsNotNone(found_peer) self.assertIs(domain.entry_peer, found_peer) found_peer = domain.find_peer( 'localhost', os.environ['NUODB_PORT'] if 'NUODB_PORT' in os.environ else domain.entry_peer.port) self.assertIsNotNone(found_peer) self.assertIs(domain.entry_peer, found_peer) 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_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_connectDomain(self): domain = None try: domain = Domain(self.host, DOMAIN_USER, DOMAIN_PASSWORD) self.assertIsNotNone(domain) self.assertFalse(domain.closed()) self.assertEqual(domain.user, DOMAIN_USER) self.assertEqual(domain.password, DOMAIN_PASSWORD) self.assertIsNotNone(domain.domain_name) self.assertIsNotNone(domain.entry_peer) self.assertIn(domain.entry_peer, domain.peers) 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_entryPeer(self): domain = None try: domain = Domain(BROKER_HOST, DOMAIN_USER, DOMAIN_PASSWORD) peer = domain.getEntryPeer() self.assertIsNotNone(peer) self.assertIs(peer.getDomain(), domain) self.assertIsNotNone(peer.getAddress()) self.assertIsNotNone(peer.getConnectStr()) self.assertIsNotNone(peer.getPort()) self.assertIsNotNone(peer.getId()) self.assertIsNotNone(peer.getHostname()) self.assertIsNotNone(peer.getVersion()) self.assertTrue(peer.isBroker()) 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_addProcess(self): domain = None database = None try: domain = Domain(BROKER_HOST, DOMAIN_USER, DOMAIN_PASSWORD) num_dbs_before = domain.getDatabaseCount() peer = domain.getEntryPeer() sm = peer.startStorageManager(TEST_DB_NAME, tempfile.mkdtemp(), True, waitSeconds=10) te = peer.startTransactionEngine(TEST_DB_NAME, [('--dba-user', DBA_USER),('--dba-password', DBA_PASSWORD)], waitSeconds=10) database = domain.getDatabase(TEST_DB_NAME) self.assertEqual(database.getProcessCount(), 2) new_te = peer.startTransactionEngine(TEST_DB_NAME, waitSeconds=10) self.assertTrue(new_te.waitForStatus('RUNNING', 10)) self.assertEqual(database.getProcessCount(), 3) 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_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_shutdownDomain(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.assertIsNotNone(database) domain.shutdown() for _ in xrange(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_killProcess(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.kill() time.sleep(1) self.assertEqual(len(database.processes), 2) finally: self._cleanup(domain)
def test_connectDomain(self): domain = None try: domain = Domain(BROKER_HOST, DOMAIN_USER, DOMAIN_PASSWORD) self.assertIsNotNone(domain) self.assertFalse(domain.closed()) self.assertEqual(domain.getUser(), DOMAIN_USER) self.assertEqual(domain.getPassword(), DOMAIN_PASSWORD) self.assertIsNotNone(domain.getDomainName()) self.assertIsNotNone(domain.getEntryPeer()) self.assertIn(domain.getEntryPeer(), domain.getPeers()) finally: self._cleanup(domain)
def test_twoDatabase(self): domain = None database1 = None database2 = None try: domain = Domain(BROKER_HOST, DOMAIN_USER, DOMAIN_PASSWORD) peer = domain.getEntryPeer() sm1 = peer.startStorageManager(TEST_DB_NAME, tempfile.mkdtemp(), True, waitSeconds=10) te1 = peer.startTransactionEngine(TEST_DB_NAME, [('--dba-user', DBA_USER),('--dba-password', DBA_PASSWORD)], waitSeconds=10) database1 = domain.getDatabase(TEST_DB_NAME) self.assertIsNotNone(database1) sm2 = peer.startStorageManager(TEST_DB_NAME2, tempfile.mkdtemp(), True, waitSeconds=10) te2 = peer.startTransactionEngine(TEST_DB_NAME2, [('--dba-user', DBA_USER),('--dba-password', DBA_PASSWORD)], waitSeconds=10) database2 = domain.getDatabase(TEST_DB_NAME2) self.assertIsNotNone(database2) self.assertNotEqual(database1, database2) self.assertIn(sm1, peer.getLocalProcesses()) self.assertIn(te1, peer.getLocalProcesses()) self.assertIn(sm2, peer.getLocalProcesses()) self.assertIn(te2, peer.getLocalProcesses()) self.assertIn(sm1, peer.getLocalProcesses(database1.getName())) self.assertIn(te1, peer.getLocalProcesses(database1.getName())) self.assertIn(sm2, peer.getLocalProcesses(database2.getName())) self.assertIn(te2, peer.getLocalProcesses(database2.getName())) self.assertNotIn(sm1, peer.getLocalProcesses(database2.getName())) self.assertNotIn(te1, peer.getLocalProcesses(database2.getName())) self.assertNotIn(sm2, peer.getLocalProcesses(database1.getName())) self.assertNotIn(te2, peer.getLocalProcesses(database1.getName())) 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(BROKER_HOST, DOMAIN_USER, DOMAIN_PASSWORD) num_dbs_before = domain.getDatabaseCount() peer = domain.getEntryPeer() sm = peer.startStorageManager(TEST_DB_NAME, tempfile.mkdtemp(), True, waitSeconds=10) self.assertIsNotNone(sm) self.assertIs(sm.getPeer(), peer) self.assertIsNotNone(sm.getAddress()) self.assertIsNotNone(sm.getPort()) self.assertIsNotNone(sm.getPid()) self.assertIsNotNone(sm.getHostname()) self.assertIsNotNone(sm.getVersion()) self.assertEqual(domain.getDatabaseCount(), num_dbs_before + 1) self.assertIn(sm, peer.getLocalProcesses()) self.assertFalse(sm.isTransactional()) database = domain.getDatabase(TEST_DB_NAME) self.assertIsNotNone(database) self.assertIn(database, domain.getDatabases()) self.assertIs(database.getDomain(), domain) self.assertEqual(database.getName(), TEST_DB_NAME) self.assertEqual(database.getProcessCount(), 1) self.assertIn(sm, database.getProcesses()) te = peer.startTransactionEngine(TEST_DB_NAME, [('--dba-user', DBA_USER),('--dba-password', DBA_PASSWORD)], waitSeconds=10) self.assertIsNotNone(te) self.assertIs(te.getPeer(), peer) self.assertIsNotNone(te.getAddress()) self.assertIsNotNone(te.getPort()) self.assertIsNotNone(te.getPid()) self.assertIsNotNone(te.getHostname()) self.assertIsNotNone(te.getVersion()) self.assertEqual(domain.getDatabaseCount(), num_dbs_before + 1) self.assertIn(te, peer.getLocalProcesses()) self.assertTrue(te.isTransactional()) self.assertEqual(database.getProcessCount(), 2) self.assertIn(te, database.getProcesses()) self.assertEqual(sm.getVersion(), te.getVersion()) self.assertIs(sm.getDatabase(), database) self.assertIs(te.getDatabase(), database) finally: self._cleanup(domain)
def test_entryPeer(self): domain = None try: domain = Domain(self.host, DOMAIN_USER, DOMAIN_PASSWORD) peer = domain.entry_peer self.assertIsNotNone(peer) self.assertIs(peer.domain, domain) self.assertIsNotNone(peer.address) self.assertIsNotNone(peer.connect_str) self.assertIsNotNone(peer.port) self.assertIsNotNone(peer.id) self.assertIsNotNone(peer.hostname) self.assertIsNotNone(peer.version) self.assertTrue(peer.is_broker) finally: self._cleanup(domain)
def test_shutdownDomain(self): domain = None database = None try: domain = Domain(BROKER_HOST, DOMAIN_USER, DOMAIN_PASSWORD) num_dbs_before = domain.getDatabaseCount() peer = domain.getEntryPeer() sm = peer.startStorageManager(TEST_DB_NAME, tempfile.mkdtemp(), True, waitSeconds=10) te = peer.startTransactionEngine(TEST_DB_NAME, [('--dba-user', DBA_USER),('--dba-password', DBA_PASSWORD)], waitSeconds=10) database = domain.getDatabase(TEST_DB_NAME) self.assertIsNotNone(database) domain.shutdown() time.sleep(1) database = domain.getDatabase(TEST_DB_NAME) self.assertIsNone(database) finally: self._cleanup(domain)
def test_existingDatabase(self): domain = None database = None try: domain = Domain(BROKER_HOST, DOMAIN_USER, DOMAIN_PASSWORD) peer = domain.getEntryPeer() sm = peer.startStorageManager(TEST_DB_NAME, tempfile.mkdtemp(), True, waitSeconds=10) te = peer.startTransactionEngine(TEST_DB_NAME, [('--dba-user', DBA_USER),('--dba-password', DBA_PASSWORD)], waitSeconds=10) database = domain.getDatabase(TEST_DB_NAME) self.assertIsNotNone(database) domain.disconnect() time.sleep(1) domain = Domain(BROKER_HOST, DOMAIN_USER, DOMAIN_PASSWORD) database = domain.getDatabase(TEST_DB_NAME) self.assertIsNotNone(database) self.assertEqual(database.getProcessCount(), 2) finally: self._cleanup(domain)
def setUp(self): self.host = BROKER_HOST + (':' + os.environ['NUODB_PORT'] if 'NUODB_PORT' in os.environ else '') domain = Domain(self.host, DOMAIN_USER, DOMAIN_PASSWORD) self._cleanup(domain)
def test_listenDomain(self): domain = None database = None dl = TestListener() try: domain = Domain(BROKER_HOST, DOMAIN_USER, DOMAIN_PASSWORD, dl) peer = domain.getEntryPeer() 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.startStorageManager(TEST_DB_NAME, tempfile.mkdtemp(), True, waitSeconds=10) i = 0 while dl.nJoined is not sm and i < 10: time.sleep(1) self.assertIs(sm, dl.nJoined) i = 0 while dl.nStatusChanged[0] is not sm and i < 10: time.sleep(1) self.assertIs(sm, dl.nStatusChanged[0]) self.assertEqual("RUNNING", dl.nStatusChanged[1]) te = peer.startTransactionEngine(TEST_DB_NAME, [('--dba-user', DBA_USER),('--dba-password', DBA_PASSWORD)], waitSeconds=10) i = 0 while dl.nJoined is not te and i < 10: time.sleep(1) self.assertIs(te, dl.nJoined) self.assertIs(te, dl.nStatusChanged[0]) self.assertEqual("RUNNING", dl.nStatusChanged[1]) database = domain.getDatabase(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) 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) 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 setUp(self): domain = Domain(BROKER_HOST, DOMAIN_USER, DOMAIN_PASSWORD) 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)
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 __init__(self, broker, user, password, listener): Domain.__init__(self, broker, user, password, listener)