def upgrade_test(self, versions, ignite_version): """ Basic upgrade test. """ versions = sorted(list(map(IgniteVersion, versions))) self.logger.info(f"Testing: {versions}") service = IgniteApplicationService( self.test_context, config=None, # will be defined later. java_class_name="org.apache.ignite.internal.ducktest.tests.persistence_upgrade_test." "DataLoaderAndCheckerApplication" ) for version in versions: service.config = IgniteConfiguration( data_storage=DataStorageConfiguration(default=DataRegionConfiguration(persistence_enabled=True)), version=version ) service.params = {"check": service.stopped} service.start(clean=False) control_utility = ControlUtility(service) control_utility.activate() service.stop()
def snapshot_test(self, ignite_version): """ Basic snapshot test. """ version = IgniteVersion(ignite_version) ignite_config = IgniteConfiguration( version=version, data_storage=DataStorageConfiguration(default=DataRegionConfiguration(persistent=True)), metric_exporter='org.apache.ignite.spi.metric.jmx.JmxMetricExporterSpi' ) nodes = IgniteService(self.test_context, ignite_config, num_nodes=len(self.test_context.cluster) - 1) nodes.start() control_utility = ControlUtility(nodes) control_utility.activate() loader_config = IgniteConfiguration(client_mode=True, version=version, discovery_spi=from_ignite_cluster(nodes)) loader = IgniteApplicationService( self.test_context, loader_config, java_class_name="org.apache.ignite.internal.ducktest.tests.snapshot_test.DataLoaderApplication", params={"start": 0, "cacheName": self.CACHE_NAME, "interval": 500_000, "valueSizeKb": 1} )
def test_tx_info(self, ignite_version): """ Tests verbose tx info for specific xid. """ servers = self.__start_ignite_nodes(ignite_version, self.NUM_NODES - 2) long_tx = self.__start_tx_app(ignite_version, servers, cache_name=self.CACHE_NAME, tx_count=2, tx_size=2, key_prefix='TX_1_KEY_') wait_for_key_locked(long_tx) control_utility = ControlUtility(servers) transactions = control_utility.tx() pick_tx = random.choice(transactions) res = control_utility.tx_info(pick_tx.xid) assert res.xid == pick_tx.xid assert res.timeout == pick_tx.timeout assert res.top_ver == pick_tx.top_ver assert res.label == pick_tx.label
def test_server_config_options(self, ignite_version): """ Test to make sure non-default non-trivial ignite node configuration XML file is generated correctly. """ ignite = IgniteService(self.test_context, get_server_config(ignite_version), 1, jvm_opts="-DCELL=1") ignite.start() control_utility = ControlUtility(ignite) control_utility.activate() ignite.stop()
def check_topology(control_utility: ControlUtility, fin_top_ver: int): """ Check current topology version. """ top_ver = control_utility.cluster_state().topology_version assert top_ver == fin_top_ver, f'Cluster current topology version={top_ver}, ' \ f'expected topology version={fin_top_ver}.'
def test_node_join(self, ignite_version, backups, cache_count, entry_count, entry_size, preloaders, thread_pool_size, batch_size, batches_prefetch_count, throttle): """ Tests rebalance on node join. """ reb_params = RebalanceParams( trigger_event=TriggerEvent.NODE_JOIN, backups=backups, cache_count=cache_count, entry_count=entry_count, entry_size=entry_size, preloaders=preloaders, thread_pool_size=thread_pool_size, batch_size=batch_size, batches_prefetch_count=batches_prefetch_count, throttle=throttle, persistent=True) ignites = start_ignite(self.test_context, ignite_version, reb_params) control_utility = ControlUtility(ignites) control_utility.activate() preload_time = preload_data( self.test_context, ignites.config._replace( client_mode=True, discovery_spi=from_ignite_cluster(ignites)), rebalance_params=reb_params) new_node = IgniteService( self.test_context, ignites.config._replace( discovery_spi=from_ignite_cluster(ignites)), num_nodes=1) new_node.start() control_utility.add_to_baseline(new_node.nodes) await_and_check_rebalance(new_node) nodes = ignites.nodes.copy() nodes.append(new_node.nodes[0]) result = get_result(new_node.nodes, preload_time, cache_count, entry_count, entry_size) control_utility.deactivate() self.logger.debug( f'DB size after rebalance: {get_database_size_mb(nodes, ignites.database_dir)}' ) return result
def test_node_left(self, ignite_version, backups, cache_count, entry_count, entry_size, preloaders, thread_pool_size, batch_size, batches_prefetch_count, throttle): """ Tests rebalance on node left. """ reb_params = RebalanceParams( trigger_event=TriggerEvent.NODE_LEFT, backups=backups, cache_count=cache_count, entry_count=entry_count, entry_size=entry_size, preloaders=preloaders, thread_pool_size=thread_pool_size, batch_size=batch_size, batches_prefetch_count=batches_prefetch_count, throttle=throttle, persistent=True) ignites = start_ignite(self.test_context, ignite_version, reb_params) control_utility = ControlUtility(ignites) control_utility.activate() preload_time = preload_data( self.test_context, ignites.config._replace( client_mode=True, discovery_spi=from_ignite_cluster(ignites)), rebalance_params=reb_params) self.logger.debug( f'DB size before rebalance: {get_database_size_mb(ignites.nodes, ignites.database_dir)}' ) node = ignites.nodes[-1] ignites.stop_node(node) assert ignites.wait_node(node) control_utility.remove_from_baseline([node]) await_and_check_rebalance(ignites) result = get_result(ignites.nodes[:-1], preload_time, cache_count, entry_count, entry_size) control_utility.deactivate() self.logger.debug( f'DB size after rebalance: {get_database_size_mb(ignites.nodes, ignites.database_dir)}' ) return result
def test_ssl_connection(self, ignite_version): """ Test that IgniteService, IgniteApplicationService correctly start and stop with ssl configurations. And check ControlUtility with ssl arguments. """ shared_root = get_shared_root_path(self.test_context.globals) server_ssl = SslParams(shared_root, key_store_jks=DEFAULT_SERVER_KEYSTORE) server_configuration = IgniteConfiguration( version=IgniteVersion(ignite_version), ssl_params=server_ssl, connector_configuration=ConnectorConfiguration( ssl_enabled=True, ssl_params=server_ssl)) ignite = IgniteService(self.test_context, server_configuration, num_nodes=2, startup_timeout_sec=180) client_configuration = server_configuration._replace( client_mode=True, ssl_params=SslParams(shared_root, key_store_jks=DEFAULT_CLIENT_KEYSTORE), connector_configuration=None) app = IgniteApplicationService( self.test_context, client_configuration, java_class_name= "org.apache.ignite.internal.ducktest.tests.smoke_test.SimpleApplication", startup_timeout_sec=180) admin_ssl = SslParams(shared_root, key_store_jks=DEFAULT_ADMIN_KEYSTORE) control_utility = ControlUtility(cluster=ignite, ssl_params=admin_ssl) ignite.start() app.start() control_utility.cluster_state() app.stop() ignite.stop()
def test_kill_tx(self, ignite_version): """ Test kill transactions by xid and filter. """ servers = self.__start_ignite_nodes(ignite_version, self.NUM_NODES - 2) tx_count = 3 long_tx_1 = self.__start_tx_app(ignite_version, servers, cache_name=self.CACHE_NAME, tx_count=tx_count, tx_size=2, key_prefix='TX_1_KEY_', label='TX_1', wait_for_topology_version=4) long_tx_2 = self.__start_tx_app(ignite_version, servers, cache_name=self.CACHE_NAME, tx_count=tx_count, tx_size=2, key_prefix='TX_2_KEY_', label='TX_2', wait_for_topology_version=4) wait_for_key_locked(long_tx_1, long_tx_2) control_utility = ControlUtility(servers) # check kill with specific xid. transactions = control_utility.tx(label_pattern='TX_1') res = control_utility.tx_kill(xid=random.choice(transactions).xid) assert res and len( res) == 1 and res[0].xid == long_tx_1.extract_result("TX_ID") # check kill with filter. res = control_utility.tx_kill(label_pattern='TX_2') assert res and len(res) == tx_count and set(map(lambda x: x.xid, res))\ .issubset(set(long_tx_2.extract_results("TX_ID")))
def await_and_check_rebalance(service: IgniteService, rebalance_nodes: list = None, is_full: bool = True): """ Check rebalance. :param service: IgniteService. :param rebalance_nodes: Ignite nodes in which rebalance will be awaited. :param is_full: Expected type of rebalancing. """ nodes = rebalance_nodes if rebalance_nodes else service.alive_nodes await_rebalance_start(service) service.await_rebalance() check_type_of_rebalancing(nodes, is_full=is_full) ControlUtility(service).idle_verify()
def test_activate_deactivate(self, ignite_version): """ Test activate and deactivate cluster. """ servers = self.__start_ignite_nodes(ignite_version, self.NUM_NODES) control_utility = ControlUtility(servers) control_utility.activate() state, _, _ = control_utility.cluster_state() assert state.lower() == 'active', 'Unexpected state %s' % state control_utility.deactivate() state, _, _ = control_utility.cluster_state() assert state.lower() == 'inactive', 'Unexpected state %s' % state
def test_change_users(self, ignite_version): """ Test add, update and remove user """ config = IgniteConfiguration( cluster_state="INACTIVE", auth_enabled=True, version=IgniteVersion(ignite_version), data_storage=DataStorageConfiguration( default=DataRegionConfiguration(persistent=True)), client_connector_configuration=ClientConnectorConfiguration()) servers = IgniteService(self.test_context, config=config, num_nodes=self.NUM_NODES - 1) servers.start() ControlUtility(cluster=servers, username=DEFAULT_AUTH_USERNAME, password=DEFAULT_AUTH_PASSWORD).activate() client_cfg = IgniteThinClientConfiguration( addresses=servers.nodes[0].account.hostname + ":" + str(config.client_connector_configuration.port), version=IgniteVersion(ignite_version), username=DEFAULT_AUTH_USERNAME, password=DEFAULT_AUTH_PASSWORD) # Add new user check_authenticate(servers, TEST_USERNAME, TEST_PASSWORD, True) self.run_with_creds(client_cfg, ADD_USER, TEST_USERNAME, TEST_PASSWORD) check_authenticate(servers, TEST_USERNAME, TEST_PASSWORD) # Update user password check_authenticate(servers, TEST_USERNAME, TEST_PASSWORD2, True) self.run_with_creds(client_cfg, UPDATE_USER, TEST_USERNAME, TEST_PASSWORD2) check_authenticate(servers, TEST_USERNAME, TEST_PASSWORD, True) check_authenticate(servers, TEST_USERNAME, TEST_PASSWORD2) # Remove user self.run_with_creds(client_cfg, REMOVE_USER, TEST_USERNAME, free=False) check_authenticate(servers, TEST_USERNAME, TEST_PASSWORD2, True)
def check_authenticate(servers, username: str, password: str, exception_expected: bool = False): """ Check if user can run control.sh command """ control_utility = ControlUtility(cluster=servers, username=username, password=password) if exception_expected: try: control_utility.cluster_state() raise Exception("Something went wrong.") except ControlUtilityError: pass else: control_utility.cluster_state()
def test_distribution(self, ignite_version): """ Tests Cellular Affinity scenario (partition distribution). """ cell1 = self.start_cell(ignite_version, ['-D' + CellularAffinity.ATTRIBUTE + '=1']) discovery_spi = from_ignite_cluster(cell1) cell2 = self.start_cell(ignite_version, ['-D' + CellularAffinity.ATTRIBUTE + '=2'], discovery_spi) cell3 = self.start_cell( ignite_version, ['-D' + CellularAffinity.ATTRIBUTE + '=XXX', '-DRANDOM=42'], discovery_spi) for cell in [cell1, cell2, cell3]: cell.await_started() ControlUtility(cell1).activate() checker = IgniteApplicationService( self.test_context, IgniteClientConfiguration( version=IgniteVersion(ignite_version), discovery_spi=from_ignite_cluster(cell1)), java_class_name= "org.apache.ignite.internal.ducktest.tests.cellular_affinity_test.DistributionChecker", params={ "cacheName": CellularAffinity.CACHE_NAME, "attr": CellularAffinity.ATTRIBUTE, "nodesPerCell": self.NODES_PER_CELL }) checker.run()
def test_latency(self, ignite_version, stop_type, discovery_type, prep_type): """ Tests Cellular switch tx latency. """ cluster_size = self.available_cluster_size cells_amount = math.floor((cluster_size - self.ZOOKEPER_CLUSTER_SIZE) / (self.NODES_PER_CELL + 1)) assert cells_amount >= 2 self.test_context.logger.info( "Cells amount calculated as %d at cluster with %d nodes in total" % (cells_amount, cluster_size)) data = {} discovery_spi = None modules = [] d_type = DiscoreryType.construct_from(discovery_type) if d_type is DiscoreryType.ZooKeeper: zk_settings = ZookeeperSettings( min_session_timeout=self.ZOOKEPER_SESSION_TIMEOUT) zk_quorum = ZookeeperService(self.test_context, self.ZOOKEPER_CLUSTER_SIZE, settings=zk_settings) zk_quorum.start() modules.append('zookeeper') discovery_spi = from_zookeeper_cluster(zk_quorum) cell0, prepared_tx_loader1 = \ self.start_cell_with_prepared_txs(ignite_version, f'C{0}', discovery_spi, modules) if d_type is DiscoreryType.TCP: discovery_spi = from_ignite_cluster(cell0) assert discovery_spi is not None loaders = [prepared_tx_loader1] nodes = [cell0] failed_cell_id = 1 for cell_id in range(1, cells_amount): # per cell coll_cnt = self.PREPARED_TX_CNT if prep_type == TxPrepType.CELL_COLOCATED else 0 # should not affect switch speed dramatically, cause recovery but not waiting # avoiding C0 (as not affected) & C1 noncoll_cnt = self.PREPARED_TX_CNT * (cells_amount - 2) \ if cell_id == failed_cell_id and prep_type == TxPrepType.CELL_NONCOLOCATED else 0 # cause waiting for txs with failed primary (~ 3/(cells-1) of prepared tx amount) # avoiding C0 (as not affected) multi_cnt = self.PREPARED_TX_CNT * (cells_amount - 1) \ if cell_id == failed_cell_id and prep_type == TxPrepType.MULTIKEY else 0 node, prepared_tx_loader = \ self.start_cell_with_prepared_txs( ignite_version, f'C{cell_id}', discovery_spi, modules, coll_cnt, noncoll_cnt, multi_cnt) loaders.append(prepared_tx_loader) nodes.append(node) failed_loader = loaders[failed_cell_id] for node in [*nodes, *loaders]: node.await_started() streamers = [] for cell in range(0, cells_amount): streamers.append( self.start_tx_streamer(ignite_version, "C%d" % cell, discovery_spi, modules)) for streamer in streamers: # starts tx streaming with latency record (with some warmup). streamer.start_async() for streamer in streamers: streamer.await_started() ControlUtility(cell0).disable_baseline_auto_adjust() # baseline set. ControlUtility(cell0).activate() for loader in loaders: loader.await_event("ALL_TRANSACTIONS_PREPARED", 180, from_the_beginning=True) for streamer in streamers: streamer.await_event("WARMUP_FINISHED", 180, from_the_beginning=True) # node left with prepared txs. with StopType.construct_from(stop_type) as s_type: if s_type is StopType.SIGTERM: failed_loader.stop_async() elif s_type is StopType.SIGKILL: failed_loader.kill() elif s_type is StopType.DROP_NETWORK: failed_loader.drop_network() for streamer in streamers: streamer.await_event("Node left topology\\|Node FAILED", 60, from_the_beginning=True) for streamer in streamers: # just an assertion that we have PME-free switch. streamer.await_event("exchangeFreeSwitch=true", 60, from_the_beginning=True) for streamer in streamers: # waiting for streaming continuation. streamer.await_event("APPLICATION_STREAMED", 60) for streamer in streamers: # stops streaming and records results. streamer.stop_async() for streamer in streamers: streamer.await_stopped() cell = streamer.params["cell"] data["[%s cell %s]" % ("alive" if cell != failed_loader.params["cell"] else "broken", cell)] = \ "worst_latency=%s, tx_streamed=%s, measure_duration=%s" % ( streamer.extract_result("WORST_LATENCY"), streamer.extract_result("STREAMED"), streamer.extract_result("MEASURE_DURATION")) return data
def test_baseline_autoadjust(self, ignite_version): """ Test activate and deactivate cluster. """ blt_size = self.NUM_NODES - 2 servers = self.__start_ignite_nodes(ignite_version, blt_size) control_utility = ControlUtility(servers) control_utility.activate() # Add node. control_utility.enable_baseline_auto_adjust(2000) new_node = self.__start_ignite_nodes(ignite_version, 1, join_cluster=servers) blt_size += 1 wait_until(lambda: len(control_utility.baseline()) == blt_size, timeout_sec=5) baseline = control_utility.baseline() self.__check_nodes_in_baseline(new_node.nodes, baseline) # Add node when auto adjust disabled. control_utility.disable_baseline_auto_adjust() old_topology = control_utility.cluster_state().topology_version new_node = self.__start_ignite_nodes(ignite_version, 1, join_cluster=servers) wait_until(lambda: control_utility.cluster_state().topology_version != old_topology, timeout_sec=5) baseline = control_utility.baseline() self.__check_nodes_not_in_baseline(new_node.nodes, baseline)
def test_baseline_set(self, ignite_version): """ Test baseline set. """ blt_size = self.NUM_NODES - 2 servers = self.__start_ignite_nodes(ignite_version, blt_size) control_utility = ControlUtility(servers) control_utility.activate() # Check baseline of activated cluster. baseline = control_utility.baseline() self.__check_baseline_size(baseline, blt_size) self.__check_nodes_in_baseline(servers.nodes, baseline) # Set baseline using list of consisttent ids. new_node = self.__start_ignite_nodes(ignite_version, 1, join_cluster=servers) control_utility.set_baseline(servers.nodes + new_node.nodes) blt_size += 1 baseline = control_utility.baseline() self.__check_baseline_size(baseline, blt_size) self.__check_nodes_in_baseline(new_node.nodes, baseline) # Set baseline using topology version. new_node = self.__start_ignite_nodes(ignite_version, 1, join_cluster=servers) _, version, _ = control_utility.cluster_state() control_utility.set_baseline(version) blt_size += 1 baseline = control_utility.baseline() self.__check_baseline_size(baseline, blt_size) self.__check_nodes_in_baseline(new_node.nodes, baseline)
def node_join_historical_test(self, ignite_version, backups, cache_count, entry_count, entry_size, preloaders, thread_pool_size, batch_size, batches_prefetch_count, throttle): """ Test historycal rebalance. """ preload_entries = 10_000 reb_params = RebalanceParams( trigger_event=TriggerEvent.NODE_JOIN, backups=backups, cache_count=cache_count, entry_count=entry_count, entry_size=entry_size, preloaders=preloaders, thread_pool_size=thread_pool_size, batch_size=batch_size, batches_prefetch_count=batches_prefetch_count, throttle=throttle, persistent=True, jvm_opts=[ '-DIGNITE_PDS_WAL_REBALANCE_THRESHOLD=0', '-DIGNITE_PREFER_WAL_REBALANCE=true' ]) ignites = start_ignite(self.test_context, ignite_version, reb_params) control_utility = ControlUtility(ignites) control_utility.activate() preloader_config = ignites.config._replace( client_mode=True, discovery_spi=from_ignite_cluster(ignites)) preloader = IgniteApplicationService( self.test_context, preloader_config, java_class_name= "org.apache.ignite.internal.ducktest.tests.rebalance.DataGenerationApplication", params={ "backups": 1, "cacheCount": 1, "entrySize": 1, "from": 0, "to": preload_entries }) preloader.run() preloader.free() control_utility.deactivate() control_utility.activate() node = ignites.nodes[-1] ignites.stop_node(node) assert ignites.wait_node(node) preload_time = preload_data( self.test_context, ignites.config._replace( client_mode=True, discovery_spi=from_ignite_cluster(ignites)), rebalance_params=reb_params) control_utility.deactivate() control_utility.activate() self.logger.debug( f'DB size before rebalance: {get_database_size_mb(ignites.nodes, ignites.database_dir)}' ) ignites.start_node(node) ignites.await_started() rebalance_nodes = [node] await_and_check_rebalance(ignites, rebalance_nodes, False) result = get_result(rebalance_nodes, preload_time, cache_count, entry_count, entry_size) control_utility.deactivate() self.logger.debug( f'DB size after rebalance: {get_database_size_mb(ignites.nodes, ignites.database_dir)}' ) return result
def test_baseline_add_remove(self, ignite_version): """ Test add and remove nodes from baseline. """ blt_size = self.NUM_NODES - 1 servers = self.__start_ignite_nodes(ignite_version, blt_size) control_utility = ControlUtility(servers) control_utility.activate() # Add node to baseline. new_node = self.__start_ignite_nodes(ignite_version, 1, join_cluster=servers) control_utility.add_to_baseline(new_node.nodes) blt_size += 1 baseline = control_utility.baseline() self.__check_baseline_size(baseline, blt_size) self.__check_nodes_in_baseline(new_node.nodes, baseline) # Expected failure (remove of online node is not allowed). try: control_utility.remove_from_baseline(new_node.nodes) assert False, "Remove of online node from baseline should fail!" except ControlUtilityError: pass # Remove of offline node from baseline. new_node.stop() servers.await_event("Node left topology", timeout_sec=30, from_the_beginning=True) control_utility.remove_from_baseline(new_node.nodes) blt_size -= 1 baseline = control_utility.baseline() self.__check_baseline_size(baseline, blt_size) self.__check_nodes_not_in_baseline(new_node.nodes, baseline)
def test_logging(self, ignite_version): """ Tests logging goes to the correct file (consistency.log) when default AI config used. """ cfg_filename = "ignite-default-log4j.xml" ignites = IgniteApplicationService( self.test_context, IgniteConfiguration( version=IgniteVersion(ignite_version), cluster_state="INACTIVE", properties=self.PROPERTIES, log4j_config=cfg_filename # default AI config (will be generated below) ), java_class_name="org.apache.ignite.internal.ducktest.tests.control_utility.InconsistentNodeApplication", params={ "cacheName": self.CACHE_NAME, "amount": 1024, "parts": 1, "tx": False }, startup_timeout_sec=180, num_nodes=len(self.test_context.cluster)) for node in ignites.nodes: # copying default AI config with log path replacement ignites.init_persistent(node) cfg_file = f"{ignites.config_dir}/{cfg_filename}" ignites.exec_command(node, f"cp {ignites.home_dir}/config/ignite-log4j.xml {cfg_file}") orig = "${IGNITE_HOME}/work/log".replace('/', '\\/') fixed = ignites.log_dir.replace('/', '\\/') ignites.exec_command(node, f"sed -i 's/{orig}/{fixed}/g' {cfg_file}") ignites.start() control_utility = ControlUtility(ignites) control_utility.activate() ignites.await_event("APPLICATION_STREAMING_FINISHED", 60, from_the_beginning=True) try: control_utility.idle_verify() # making sure we have broken data raise IgniteExecutionException("Fail.") except AssertionError: pass control_utility.check_consistency(f"repair {self.CACHE_NAME} 0") # checking/repairing message = "Cache consistency violations recorded." ignites.await_event(message, 60, from_the_beginning=True, log_file="consistency.log") try: ignites.await_event(message, 10, from_the_beginning=True) raise IgniteExecutionException("Fail.") except TimeoutError: pass
def test(self, ignite_version, load_type): """ Tests PME-free switch scenario (node stop). """ data = {} caches = [CacheConfiguration(name='test-cache', backups=2, atomicity_mode='TRANSACTIONAL')] l_type = LoadType.construct_from(load_type) # Checking PME (before 2.8) vs PME-free (2.8+) switch duration, but # focusing on switch duration (which depends on caches amount) when long_txs is false and # on waiting for previously started txs before the switch (which depends on txs duration) when long_txs of true. if l_type is LoadType.EXTRA_CACHES: for idx in range(1, self.EXTRA_CACHES_AMOUNT): caches.append(CacheConfiguration(name="cache-%d" % idx, backups=2, atomicity_mode='TRANSACTIONAL')) config = IgniteConfiguration(version=IgniteVersion(ignite_version), caches=caches, cluster_state="INACTIVE") num_nodes = len(self.test_context.cluster) - 2 self.test_context.logger.info("Nodes amount calculated as %d." % num_nodes) ignites = IgniteService(self.test_context, config, num_nodes=num_nodes) ignites.start() if IgniteVersion(ignite_version) >= V_2_8_0: ControlUtility(ignites).disable_baseline_auto_adjust() ControlUtility(ignites).activate() client_config = config._replace(client_mode=True, discovery_spi=from_ignite_cluster(ignites, slice(0, num_nodes - 1))) long_tx_streamer = IgniteApplicationService( self.test_context, client_config, java_class_name="org.apache.ignite.internal.ducktest.tests.pme_free_switch_test.LongTxStreamerApplication", params={"cacheName": "test-cache"}, startup_timeout_sec=180) if l_type is LoadType.LONG_TXS: long_tx_streamer.start() single_key_tx_streamer = IgniteApplicationService( self.test_context, client_config, java_class_name="org.apache.ignite.internal.ducktest.tests.pme_free_switch_test." "SingleKeyTxStreamerApplication", params={"cacheName": "test-cache", "warmup": 1000}, startup_timeout_sec=180) single_key_tx_streamer.start() ignites.stop_node(ignites.nodes[num_nodes - 1]) single_key_tx_streamer.await_event("Node left topology", 60, from_the_beginning=True) if l_type is LoadType.LONG_TXS: time.sleep(30) # keeping txs alive for 30 seconds. long_tx_streamer.stop_async() single_key_tx_streamer.await_event("Node left topology", 60, from_the_beginning=True) single_key_tx_streamer.await_event("APPLICATION_STREAMED", 60) # waiting for streaming continuation. single_key_tx_streamer.stop() data["Worst latency (ms)"] = single_key_tx_streamer.extract_result("WORST_LATENCY") data["Streamed txs"] = single_key_tx_streamer.extract_result("STREAMED") data["Measure duration (ms)"] = single_key_tx_streamer.extract_result("MEASURE_DURATION") data["Server nodes"] = num_nodes return data
def test_tx_filter(self, ignite_version): """ Test filtering transactions list. """ servers = self.__start_ignite_nodes(ignite_version, self.NUM_NODES - 2) client_tx_count, client_tx_size = 5, 4 server_tx_count, server_tx_size = 3, 2 servers = self.__start_tx_app(ignite_version, servers, client_mode=False, cache_name=self.CACHE_NAME, tx_count=server_tx_count, tx_size=server_tx_size, key_prefix='TX_1_KEY_', label='LBL_SERVER', wait_for_topology_version=4) clients = self.__start_tx_app(ignite_version, servers, cache_name=self.CACHE_NAME, tx_count=client_tx_count, tx_size=client_tx_size, key_prefix='TX_2_KEY_', label='LBL_CLIENT', wait_for_topology_version=4) wait_for_key_locked(clients, servers) control_utility = ControlUtility(servers) start_check = self.monotonic() assert len(control_utility.tx( clients=True, label_pattern='LBL_.*')) == client_tx_count assert len(control_utility.tx( servers=True, label_pattern='LBL_.*')) == server_tx_count # limit to 2 transactions on each node, therefore 4 total. assert len(control_utility.tx(limit=2, label_pattern='LBL_.*')) == 4 assert len(control_utility.tx( label_pattern='LBL_.*')) == client_tx_count + server_tx_count # filter transactions with keys size greater or equal to min_size. assert len( control_utility.tx(min_size=client_tx_size, label_pattern='LBL_.*')) == client_tx_count server_nodes = [node.consistent_id for node in servers.nodes] assert len( control_utility.tx(label_pattern='LBL_.*', nodes=server_nodes)) == server_tx_count # test ordering. for order_type in ['DURATION', 'SIZE', 'START_TIME']: transactions = control_utility.tx(label_pattern='LBL_.*', order=order_type) assert is_sorted( transactions, key=lambda x, attr=order_type: getattr(x, attr.lower()), reverse=True) # test min_duration filtering. min_duration = int(self.monotonic() - start_check) transactions = control_utility.tx(min_duration=min_duration, label_pattern='LBL_.*') assert len(transactions) == server_tx_count + client_tx_count for tx in transactions: assert tx.duration >= min_duration
def ignite_start_stop(self, ignite_version, graceful_shutdown, nodes_num, static_clients_num, temp_client, iteration_count, client_work_time): """ Test for starting and stopping fat clients. """ servers_count = nodes_num - static_clients_num - temp_client current_top_v = servers_count # Topology version after test. fin_top_ver = servers_count + (2 * static_clients_num) + ( 2 * iteration_count * temp_client) server_cfg = IgniteConfiguration( version=IgniteVersion(ignite_version), caches=[ CacheConfiguration(name=self.CACHE_NAME, backups=1, atomicity_mode='TRANSACTIONAL') ]) ignite = IgniteService(self.test_context, server_cfg, num_nodes=servers_count) control_utility = ControlUtility(ignite) client_cfg = server_cfg._replace(client_mode=True) static_clients = IgniteApplicationService( self.test_context, client_cfg, java_class_name=self.JAVA_CLIENT_CLASS_NAME, num_nodes=static_clients_num, params={ "cacheName": self.CACHE_NAME, "pacing": self.PACING }) temp_clients = IgniteApplicationService( self.test_context, client_cfg, java_class_name=self.JAVA_CLIENT_CLASS_NAME, num_nodes=temp_client, params={ "cacheName": self.CACHE_NAME, "pacing": self.PACING }) ignite.start() static_clients.start() current_top_v += static_clients_num check_topology(control_utility, current_top_v) # Start / stop temp_clients node. Check cluster. for i in range(iteration_count): self.logger.info(f'Starting iteration: {i}.') temp_clients.start() current_top_v += temp_client await_event(static_clients, f'ver={current_top_v}, locNode=') check_topology(control_utility, current_top_v) await_event(temp_clients, f'clients={static_clients_num + temp_client}') time.sleep(client_work_time) if graceful_shutdown: temp_clients.stop() else: temp_clients.kill() current_top_v += temp_client await_event(static_clients, f'ver={current_top_v}, locNode=') static_clients.stop() check_topology(control_utility, fin_top_ver)