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)
