def test_config_add_to_result(self, ignite_version, is_ignite_service): """ Test that the config file is in config directory and Service.logs contains the config directory to add to the result. """ ignite_cfg = IgniteConfiguration(version=IgniteVersion(ignite_version)) if is_ignite_service: ignite = IgniteService(self.test_context, ignite_cfg, num_nodes=1) else: ignite = IgniteApplicationService( self.test_context, ignite_cfg, java_class_name= "org.apache.ignite.internal.ducktest.tests.self_test.TestKillableApplication" ) ignite.start() assert ignite.logs.get('config').get('path') == ignite.config_dir assert ignite.config_file.startswith(ignite.config_dir) ignite.nodes[0].account.ssh( f'ls {ignite.config_dir} | grep {os.path.basename(ignite.config_file)}' ) ignite.nodes[0].account.ssh( f'ls {ignite.config_dir} | grep {os.path.basename(ignite.log_config_file)}' ) ignite.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 __start_ignite_nodes(self, version, num_nodes, timeout_sec=60, join_cluster=None): config = IgniteConfiguration( cluster_state="INACTIVE", version=IgniteVersion(version), data_storage=DataStorageConfiguration( default=DataRegionConfiguration(name='persistent', persistence_enabled=True), regions=[ DataRegionConfiguration(name='in-memory', persistence_enabled=False, max_size=100 * 1024 * 1024) ])) if join_cluster: config._replace(discovery_spi=from_ignite_cluster(join_cluster)) servers = IgniteService(self.test_context, config=config, num_nodes=num_nodes, startup_timeout_sec=timeout_sec) servers.start() return servers
def __run(self, ignite_version, trigger_event, backups, cache_count, entry_count, entry_size, preloaders, thread_pool_size, batch_size, batches_prefetch_count, throttle): """ Test performs rebalance test which consists of following steps: * Start cluster. * Put data to it via IgniteClientApp. * Triggering a rebalance event and awaits for rebalance to finish. :param ignite_version: Ignite version. :param trigger_event: Trigger event. :param backups: Backup count. :param cache_count: Cache count. :param entry_count: Cache entry count. :param entry_size: Cache entry size. :param preloaders: Preload application nodes count. :param thread_pool_size: rebalanceThreadPoolSize config property. :param batch_size: rebalanceBatchSize config property. :param batches_prefetch_count: rebalanceBatchesPrefetchCount config property. :param throttle: rebalanceThrottle config property. :return: Rebalance and data preload stats. """ reb_params = RebalanceParams( trigger_event=trigger_event, 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) ignites = start_ignite(self.test_context, ignite_version, reb_params) preload_time = preload_data( self.test_context, ignites.config._replace( client_mode=True, discovery_spi=from_ignite_cluster(ignites)), rebalance_params=reb_params) if trigger_event: ignites.stop_node(ignites.nodes[-1]) rebalance_nodes = ignites.nodes[:-1] else: ignite = IgniteService( self.test_context, ignites.config._replace( discovery_spi=from_ignite_cluster(ignites)), num_nodes=1) ignite.start() rebalance_nodes = ignite.nodes await_rebalance_start(ignite) ignite.await_rebalance() return get_result(rebalance_nodes, preload_time, cache_count, entry_count, entry_size)
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_ignite_start_stop(self, ignite_version): """ Test that IgniteService correctly start and stop """ ignite = IgniteService( self.test_context, IgniteConfiguration(version=IgniteVersion(ignite_version)), num_nodes=1) print(self.test_context) ignite.start() ignite.stop()
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 start_servers(test_context, num_nodes, ignite_config, modules=None): """ Start ignite servers. """ servers = IgniteService( test_context, config=ignite_config, num_nodes=num_nodes, modules=modules, # mute spam in log. jvm_opts=["-DIGNITE_DUMP_THREADS_ON_FAILURE=false"]) start = monotonic() servers.start() return servers, round(monotonic() - start, 1)
def __start_ignite_nodes(self, version, num_nodes, timeout_sec=60): config = IgniteConfiguration(cluster_state="ACTIVE", version=IgniteVersion(version), caches=[ CacheConfiguration( name=self.CACHE_NAME, atomicity_mode='TRANSACTIONAL') ]) servers = IgniteService(self.test_context, config=config, num_nodes=num_nodes, startup_timeout_sec=timeout_sec) servers.start() return servers
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_simple_services_start_stop(self, ignite_version): """ Tests plain services start and stop (termitation vs self-terination). """ ignites = IgniteService( self.test_context, IgniteConfiguration(version=IgniteVersion(ignite_version)), num_nodes=1) ignites.start() client = IgniteService( self.test_context, IgniteClientConfiguration(version=IgniteVersion(ignite_version)), num_nodes=1) client.start() node1 = IgniteApplicationService( self.test_context, IgniteClientConfiguration( version=IgniteVersion(ignite_version), discovery_spi=from_ignite_cluster(ignites)), java_class_name= "org.apache.ignite.internal.ducktest.tests.self_test.TestKillableApplication", startup_timeout_sec=180) node2 = IgniteApplicationService( self.test_context, IgniteClientConfiguration( version=IgniteVersion(ignite_version), discovery_spi=from_ignite_cluster(ignites)), java_class_name= "org.apache.ignite.internal.ducktest.tests.self_test.TestSelfKillableApplication", startup_timeout_sec=180) node1.start() node2.run() node1.stop() client.stop() ignites.stop()
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 start_ignite(test_context, ignite_version: str, rebalance_params: RebalanceParams) -> IgniteService: """ Start IgniteService: :param test_context: Test context. :param ignite_version: Ignite version. :param rebalance_params: Rebalance parameters. :return: IgniteService. """ node_count = test_context.available_cluster_size - rebalance_params.preloaders if rebalance_params.persistent: data_storage = DataStorageConfiguration( max_wal_archive_size=2 * rebalance_params.data_region_max_size, default=DataRegionConfiguration( persistence_enabled=True, max_size=rebalance_params.data_region_max_size)) else: data_storage = DataStorageConfiguration( default=DataRegionConfiguration( max_size=rebalance_params.data_region_max_size)) node_config = IgniteConfiguration( version=IgniteVersion(ignite_version), data_storage=data_storage, metric_exporters={ "org.apache.ignite.spi.metric.jmx.JmxMetricExporterSpi" }, rebalance_thread_pool_size=rebalance_params.thread_pool_size, rebalance_batch_size=rebalance_params.batch_size, rebalance_batches_prefetch_count=rebalance_params. batches_prefetch_count, rebalance_throttle=rebalance_params.throttle) ignites = IgniteService(test_context, config=node_config, num_nodes=node_count if rebalance_params.trigger_event else node_count - 1, jvm_opts=rebalance_params.jvm_opts) ignites.start() return ignites
def test_logs_rotation(self, ignite_version): """ Test logs rotation after ignite service restart. """ def get_log_lines_count(service, filename): node = service.nodes[0] log_file = os.path.join(service.log_dir, filename) log_cnt = list( node.account.ssh_capture(f'cat {log_file} | wc -l', callback=int))[0] return log_cnt def get_logs_count(service): node = service.nodes[0] return list( node.account.ssh_capture( f'ls {service.log_dir}/ignite.log* | wc -l', callback=int))[0] ignites = IgniteService( self.test_context, IgniteConfiguration(version=IgniteVersion(ignite_version)), num_nodes=1) ignites.start() num_restarts = 6 for i in range(num_restarts - 1): ignites.stop() old_cnt = get_log_lines_count(ignites, "ignite.log") assert old_cnt > 0 ignites.start(clean=False) new_cnt = get_log_lines_count(ignites, "ignite.log") assert new_cnt > 0 # check that there is no new entry in rotated file assert old_cnt == get_log_lines_count(ignites, f"ignite.log.{i + 1}") assert get_logs_count(ignites) == num_restarts
def test_thin_client_compatibility(self, server_version, thin_client_version): """ Thin client compatibility test. """ server_config = IgniteConfiguration(version=IgniteVersion(server_version), client_connector_configuration=ClientConnectorConfiguration()) ignite = IgniteService(self.test_context, server_config, 1) addresses = ignite.nodes[0].account.hostname + ":" + str(server_config.client_connector_configuration.port) thin_clients = IgniteApplicationService(self.test_context, IgniteThinClientConfiguration(addresses=addresses, version=IgniteVersion( thin_client_version)), java_class_name=self.JAVA_CLIENT_CLASS_NAME, num_nodes=1) ignite.start() thin_clients.run() ignite.stop()
def test_ignite_app_start_stop(self, ignite_version): """ Test that IgniteService and IgniteApplicationService correctly start and stop """ server_configuration = IgniteConfiguration( version=IgniteVersion(ignite_version)) ignite = IgniteService(self.test_context, server_configuration, num_nodes=1) client_configuration = server_configuration._replace( client_mode=True, discovery_spi=from_ignite_cluster(ignite)) app = IgniteApplicationService( self.test_context, client_configuration, java_class_name= "org.apache.ignite.internal.ducktest.tests.smoke_test.SimpleApplication" ) ignite.start() app.start() app.stop() ignite.stop()
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 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)