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 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()
