This is an automated email from the ASF dual-hosted git repository.
anton-vinogradov pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/ignite.git
The following commit(s) were added to refs/heads/master by this push:
new 665f284296a IGNITE-29049 [ducktests] Fix the JMX metric registry MBean
lookup (#13575)
665f284296a is described below
commit 665f284296a35baad18c7f3a0664714579c79b21
Author: Maksim Davydov <[email protected]>
AuthorDate: Wed Sep 30 19:20:34 2026 +0300
IGNITE-29049 [ducktests] Fix the JMX metric registry MBean lookup (#13575)
---
.../ducktests/tests/checks/support/mbean_grep.py | 59 ++++++++
.../checks/utils/check_metric_registry_pattern.py | 88 +++++++++++
.../ignitetest/services/utils/cdc/cdc_helper.py | 8 +-
.../ignitetest/services/utils/control_utility.py | 13 +-
.../ignitetest/services/utils/ignite_aware.py | 6 +-
.../tests/ignitetest/services/utils/jmx_utils.py | 166 +++++++++++++++++----
.../ducktests/tests/ignitetest/tests/dump_test.py | 4 +-
.../tests/ignitetest/tests/rebalance/util.py | 8 +-
8 files changed, 305 insertions(+), 47 deletions(-)
diff --git a/modules/ducktests/tests/checks/support/mbean_grep.py
b/modules/ducktests/tests/checks/support/mbean_grep.py
new file mode 100644
index 00000000000..bae2bb44cfa
--- /dev/null
+++ b/modules/ducktests/tests/checks/support/mbean_grep.py
@@ -0,0 +1,59 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+The MBean lookup of a JMX client, for checks of the patterns it is handed.
+
+The client pipes the MBean list of a node through 'grep -E -o <pattern> | grep
-E -v <negative pattern>'.
+The functions here run a single MBean name through the same pipeline: once
with Python's re, and once
+with 'grep -E' itself where a grep is installed - the patterns are EREs, not
Python regular expressions.
+"""
+import re
+import shutil
+import subprocess
+
+GREP = shutil.which("grep")
+
+
+def python_grep(pattern, negative_pattern, mbean_name):
+ """
+ :return: The part of the name the patterns leave, as 'grep -E -o | grep -E
-v' would return it.
+ """
+ match = re.search(pattern, mbean_name)
+
+ if not match or (negative_pattern and re.search(negative_pattern,
match.group())):
+ return None
+
+ return match.group()
+
+
+def real_grep(tmp_path, pattern, negative_pattern, mbean_name):
+ """
+ :return: The same as :func:`python_grep`, but produced by 'grep -E'
itself. The patterns go
+ through files, since a quote in a command line argument does not
survive Windows.
+ """
+ def grep(flag, grep_pattern, text):
+ pattern_file = tmp_path / f"pattern{flag}"
+ pattern_file.write_bytes((grep_pattern + "\n").encode())
+
+ return subprocess.run([GREP, "-E", flag, "-f", str(pattern_file)],
input=text.encode(),
+ capture_output=True).stdout.decode()
+
+ out = grep("-o", pattern, mbean_name + "\n")
+
+ if out and negative_pattern:
+ out = grep("-v", negative_pattern, out)
+
+ return out.strip() or None
diff --git
a/modules/ducktests/tests/checks/utils/check_metric_registry_pattern.py
b/modules/ducktests/tests/checks/utils/check_metric_registry_pattern.py
new file mode 100644
index 00000000000..872e3460e42
--- /dev/null
+++ b/modules/ducktests/tests/checks/utils/check_metric_registry_pattern.py
@@ -0,0 +1,88 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Checks the MBean name pattern of a metric registry.
+
+The pattern is grepped against the MBean list of a node, so it is checked here
the same way:
+the match has to cover the WHOLE object name, since that name is what the
following
+'get -b <name>' is issued against. Every case runs through Python's re and,
where a grep is
+installed, through 'grep -E' itself - see checks.support.mbean_grep.
+"""
+import pytest
+
+from ignitetest.services.utils.jmx_utils import metric_registry_pattern
+
+from checks.support.mbean_grep import GREP, python_grep, real_grep
+
+# MBean names as a node prints them: the properties are ordered
alphabetically, which puts
+# the instance name between the group and the name.
+PREFIX =
"org.apache:clsLdr=3e2a56ab,group=%s,igniteInstanceName=ducker01,name=%s"
+NO_GROUP_PREFIX =
"org.apache:clsLdr=3e2a56ab,igniteInstanceName=ducker01,name=%s"
+
+
+# (registry, MBean name, whether the registry's pattern must match that name)
+# One case per way the exporter spells a name: a new cache needs no case
unless its name is spelled a new way.
+CASES = [
+ # A purely alphanumeric name is registered without quotes.
+ ("cache.myCache", PREFIX % ("cache", "myCache"), True),
+ ("cache.cache_1", PREFIX % ("cache", "cache_1"), True),
+ # Anything else - a dash is enough - is registered quoted, closing quote
included.
+ ("cache.my-cache", PREFIX % ("cache", '"my-cache"'), True),
+ # Only the FIRST dot splits the registry, so the rest of it is the MBean
name.
+ ("io.dataregion.default", PREFIX % ("io", '"dataregion.default"'), True),
+ # 'cache' must not pick up 'cacheGroups': the two hold different metrics
of the same cache.
+ ("cache.my-cache", PREFIX % ("cacheGroups", '"my-cache"'), False),
+ ("cacheGroups.my-cache", PREFIX % ("cacheGroups", '"my-cache"'), True),
+ # 'name' sorts last, so the pattern ends at the end of the line and a
longer name does not answer.
+ ("cache.myCache", PREFIX % ("cache", "myCacheV2"), False),
+ ("cache.my-cache", PREFIX % ("cache", '"my-cache-2"'), False),
+ # The name is matched literally, ERE metacharacters included.
+ ("cache.my.cache", PREFIX % ("cache", '"myXcache"'), False),
+ ("cache.my.cache", PREFIX % ("cache", '"my.cache"'), True),
+ ("cache.a(b)+c", PREFIX % ("cache", '"a(b)+c"'), True),
+ ("cache.a(b)+c", PREFIX % ("cache", '"abbc"'), False),
+ # Characters that are special only right after an opening '[' or '{' stay
unescaped.
+ ("cache.a]b}c", PREFIX % ("cache", '"a]b}c"'), True),
+ ("cache.a[b]{2}", PREFIX % ("cache", '"a[b]{2}"'), True),
+ ("cache.a[b]{2}", PREFIX % ("cache", '"abb"'), False),
+ # The exporter escapes '*' inside the quotes.
+ ("cache.a*b", PREFIX % ("cache", r'"a\*b"'), True),
+ # A registry without a dot has no group, and must not pick up the system
view of the same name.
+ ("snapshot", NO_GROUP_PREFIX % "snapshot", True),
+ ("snapshot", PREFIX % ("views", "snapshot"), False),
+ ("cdc", PREFIX % ("cdc", "consumer"), False),
+]
+
+
+class CheckMetricRegistryPattern:
+ """
+ Checks that the pattern covers how the JMX exporter really names a
registry.
+ """
+ @pytest.mark.parametrize(["registry", "mbean_name", "expected"], CASES)
+ def check_the_pattern_matches_exactly_the_registry(self, registry,
mbean_name, expected):
+ assert python_grep(*metric_registry_pattern(registry), mbean_name) ==
(mbean_name if expected else None)
+
+ @pytest.mark.skipif(GREP is None, reason="grep is not installed")
+ @pytest.mark.parametrize(["registry", "mbean_name", "expected"], CASES)
+ def check_grep_agrees(self, tmp_path, registry, mbean_name, expected):
+ assert real_grep(tmp_path, *metric_registry_pattern(registry),
mbean_name) == \
+ (mbean_name if expected else None)
+
+ @pytest.mark.parametrize("registry", ["cache.it's", 'cache.a"b',
"cache.a\\b", "cache.a?b"])
+ def check_a_name_the_jmxterm_commands_cannot_carry_is_rejected(self,
registry):
+ """The MBean name goes through the shell quoting of the grep and
jmxterm commands."""
+ with pytest.raises(ValueError):
+ metric_registry_pattern(registry)
diff --git
a/modules/ducktests/tests/ignitetest/services/utils/cdc/cdc_helper.py
b/modules/ducktests/tests/ignitetest/services/utils/cdc/cdc_helper.py
index 9965dbde21f..0b8f83fb93a 100644
--- a/modules/ducktests/tests/ignitetest/services/utils/cdc/cdc_helper.py
+++ b/modules/ducktests/tests/ignitetest/services/utils/cdc/cdc_helper.py
@@ -207,8 +207,6 @@ def last_ignite_cdc_event_time(ignite_cdc):
:return: Timestamp of the last CDC event (unix time in seconds).
"""
def last_event_time_on(node):
- jmx_client = JmxClient(node)
-
if isinstance(ignite_cdc, IgniteCdcUtility):
main_java_class = ignite_cdc.APP_SERVICE_CLASS
else:
@@ -219,12 +217,12 @@ def last_ignite_cdc_event_time(ignite_cdc):
if len(pids) == 0:
raise AssertionError("ignite_cdc java process is not found on
node: " + node.account.hostname)
- jmx_client.pid = pids[0]
+ jmx_client = JmxClient(node, pids[0])
try:
- mbean = jmx_client.find_mbean('.*name=cdc.*')
+ mbean = jmx_client.find_metric_registry('cdc')
- return int(next(mbean.LastEventTime).strip())
+ return int(mbean.value("LastEventTime"))
except (StopIteration, RemoteCommandError):
ignite_cdc.logger.warn("Filed to read LastEventTime metric from
ignite_cdc, node: " + node.account.hostname)
diff --git
a/modules/ducktests/tests/ignitetest/services/utils/control_utility.py
b/modules/ducktests/tests/ignitetest/services/utils/control_utility.py
index 8ace03db5ae..329e5321974 100644
--- a/modules/ducktests/tests/ignitetest/services/utils/control_utility.py
+++ b/modules/ducktests/tests/ignitetest/services/utils/control_utility.py
@@ -28,7 +28,6 @@ from ducktape.cluster.remoteaccount import RemoteCommandError
from ignitetest.services.utils.auth import get_credentials, is_auth_enabled
from ignitetest.services.utils.ignite_spec import envs_to_exports
from ignitetest.services.utils.ssl.ssl_params import get_ssl_params,
is_ssl_enabled, IGNITE_ADMIN_ALIAS
-from ignitetest.services.utils.jmx_utils import JmxClient
from ignitetest.utils.version import V_2_11_0
@@ -303,17 +302,17 @@ class ControlUtility:
while datetime.now() < delta_time:
for node in self._cluster.nodes:
- mbean = JmxClient(node).find_mbean('.*name=snapshot.*',
negative_pattern='group=views')
+ mbean = node.metric_registry_mbean('snapshot')
- if snapshot_name != next(mbean.LastSnapshotName, ""):
+ if snapshot_name != mbean.value("LastSnapshotName", ""):
continue
- start_time = int(next(mbean.LastSnapshotStartTime))
- end_time = int(next(mbean.LastSnapshotEndTime))
- err_msg = next(mbean.LastSnapshotErrorMessage)
+ start_time = int(mbean.value("LastSnapshotStartTime"))
+ end_time = int(mbean.value("LastSnapshotEndTime"))
+ err_msg = mbean.value("LastSnapshotErrorMessage")
if (start_time < end_time) and (err_msg == ''):
- assert snapshot_name == next(mbean.LastSnapshotName)
+ assert snapshot_name == mbean.value("LastSnapshotName")
return
raise TimeoutError(f'Failed to wait for the snapshot operation to
complete: '
diff --git a/modules/ducktests/tests/ignitetest/services/utils/ignite_aware.py
b/modules/ducktests/tests/ignitetest/services/utils/ignite_aware.py
index 3e148217945..e0f81ab35b7 100644
--- a/modules/ducktests/tests/ignitetest/services/utils/ignite_aware.py
+++ b/modules/ducktests/tests/ignitetest/services/utils/ignite_aware.py
@@ -37,7 +37,7 @@ from ignitetest.services.utils import IgniteServiceType
from ignitetest.services.utils.background_thread import BackgroundThreadService
from ignitetest.services.utils.concurrent import CountDownLatch, AtomicValue
from ignitetest.services.utils.ignite_spec import resolve_spec,
SHARED_PREPARED_FILE
-from ignitetest.services.utils.jmx_utils import ignite_jmx_mixin, JmxClient
+from ignitetest.services.utils.jmx_utils import ignite_jmx_mixin
from ignitetest.services.utils.jvm_utils import JvmProcessMixin,
JvmVersionMixin
from ignitetest.services.utils.log_utils import monitor_log
from ignitetest.services.utils.path import IgnitePathAware
@@ -611,10 +611,10 @@ class IgniteAwareService(BackgroundThreadService,
IgnitePathAware, JvmProcessMix
node = random.choice(self.alive_nodes)
rebalanced = False
- mbean = JmxClient(node).find_mbean('.*name=cluster')
+ mbean = node.metric_registry_mbean('cluster')
while datetime.now() < delta_time and not rebalanced:
- rebalanced = next(mbean.Rebalanced) == 'true'
+ rebalanced = mbean.bool_value("Rebalanced")
if rebalanced:
return
diff --git a/modules/ducktests/tests/ignitetest/services/utils/jmx_utils.py
b/modules/ducktests/tests/ignitetest/services/utils/jmx_utils.py
index 48cfe00003f..73ca0abdc46 100644
--- a/modules/ducktests/tests/ignitetest/services/utils/jmx_utils.py
+++ b/modules/ducktests/tests/ignitetest/services/utils/jmx_utils.py
@@ -20,21 +20,87 @@ and attributes.
import os
import re
-from ignitetest.services.utils.decorators import memoize
from ignitetest.services.utils.jvm_utils import java_version,
java_major_version
+_NO_DEFAULT = object()
+
+# Not allowed in a metric registry name: the single quote would break the
quoted grep argument, and the
+# $'...' quoting of the jmxterm commands turns the exporter's \" and \?
escapes, and a lone backslash, into
+# something else.
+_UNSUPPORTED_REGISTRY_CHARS = frozenset("'\"\\?")
+
+
+def _object_name_value(value):
+ """
+ Spells a property value the way IgniteUtils.escapeObjectNameValue() does:
as is when it is
+ purely alphanumeric or underscore, otherwise quoted, with backslash,
quote, '?' and '*' escaped.
+ """
+ if re.fullmatch(r'[A-Za-z0-9_]+', value):
+ return value
+
+ return '"' + re.sub(r'([\\"?*])', r'\\\1', value) + '"'
+
+
+def _ere_escape(value):
+ """
+ Escapes a literal for a POSIX extended regular expression, which is what
'grep -E' reads -
+ re.escape() escapes for the Python dialect instead.
+ """
+ return re.sub(r'([\[\\.^$*+?(){|])', r'\\\1', value)
+
+
+def metric_registry_pattern(registry):
+ """
+ Builds the MBean name pattern of a single metric registry.
+
+ The JMX metric exporter splits a registry name at its FIRST dot and makes
the head the
+ MBean group and the tail its name: ``cache.myCache`` becomes
``group=cache`` plus
+ ``name=myCache``, ``io.dataregion.default`` becomes ``group=io`` plus
+ ``name="dataregion.default"``. A registry without a dot, ``snapshot`` say,
gets no group at all.
+
+ Both values are spelled as the exporter spells them - quoted and escaped
unless purely
+ alphanumeric - and matched literally. The properties of an MBean name are
ordered
+ alphabetically, so the group always comes before the name but never right
next to it. And
+ ``name`` sorts last of them all, so the pattern ends at the end of the
line: without that
+ anchor ``myCache`` would also match the registry of ``myCacheV2``.
+
+ A registry without a group needs the negative pattern as well - an ERE has
no lookahead, and
+ the system view of the same name (``group=views,...,name=snapshot``)
matches otherwise.
+
+ The MBean name of a registry carries no pid, but it does carry the class
loader hash, so it
+ may differ between two runs of a node.
+
+ :param registry: Metric registry name. It must not contain a single or
double quote, a backslash
+ or a question mark - see :data:`_UNSUPPORTED_REGISTRY_CHARS`.
+ :return: Tuple of the pattern and the negative pattern to pass to
:meth:`JmxClient.find_mbean`.
+ """
+ if _UNSUPPORTED_REGISTRY_CHARS.intersection(registry):
+ raise ValueError(f"A metric registry name with a quote, a backslash or
'?' is not supported: {registry}")
+
+ group, dot, name = registry.partition('.')
+
+ if not dot:
+ return rf'.*name={_ere_escape(_object_name_value(registry))}\s*$',
'group='
+
+ return rf'.*group={_ere_escape(_object_name_value(group))},' \
+ rf'.*name={_ere_escape(_object_name_value(name))}\s*$', None
+
def ignite_jmx_mixin(node, service):
"""
- Dynamically mixin JMX attributes to Ignite service node.
+ Dynamically mixin JMX attributes to Ignite service node. Called on every
start of the node,
+ which is what hands a restarted node a JMX client of its new JVM.
:param node: Ignite service node.
:param service: Ignite service.
"""
setattr(node, 'pids', service.pids(node, service.main_java_class))
setattr(node, 'install_root', service.install_root)
- base_cls = node.__class__
- base_cls_name = node.__class__.__name__
- node.__class__ = type(base_cls_name, (base_cls, IgniteJmxMixin), {})
+ setattr(node, '_jmx_client', None)
+
+ if not isinstance(node, IgniteJmxMixin):
+ base_cls = node.__class__
+ base_cls_name = node.__class__.__name__
+ node.__class__ = type(base_cls_name, (base_cls, IgniteJmxMixin), {})
class JmxMBean:
@@ -53,6 +119,30 @@ class JmxMBean:
"""
return self.client.mbean_attribute(self.name, attr)
+ def value(self, attr, default=_NO_DEFAULT):
+ """
+ Reads a single valued attribute - which is what a metric read almost
always wants,
+ as opposed to the raw line iterator the attribute access itself
returns.
+
+ :param attr: Attribute name.
+ :param default: Value to return if the attribute reads nothing;
StopIteration is raised if not passed.
+ :return: Attribute value, whitespace stripped.
+ """
+ try:
+ return next(self.client.mbean_attribute(self.name, attr)).strip()
+ except StopIteration:
+ if default is _NO_DEFAULT:
+ raise
+
+ return default
+
+ def bool_value(self, attr):
+ """
+ :param attr: Attribute name.
+ :return: Attribute value as a boolean; anything but "true" is False.
+ """
+ return self.value(attr).lower() == "true"
+
def run(self, operation, params):
""""
Runs through JMX client MBean operation.
@@ -66,11 +156,16 @@ class JmxMBean:
class JmxClient:
"""JMX client, invokes jmxterm on node locally.
"""
- def __init__(self, node):
+ def __init__(self, node, pid=None):
+ """
+ :param node: Node to run jmxterm on.
+ :param pid: JVM to connect to; the first of the node's pids if not
passed.
+ """
self.node = node
self.install_root = node.install_root
- self.pid = node.pids[0]
+ self.pid = pid if pid is not None else node.pids[0]
self.java_major = java_major_version(java_version(self.node))
+ self._mbeans = {}
@property
def jmx_util_cmd(self):
@@ -81,24 +176,34 @@ class JmxClient:
return os.path.join(f"java {extra_flag} -jar
{self.install_root}/jmxterm.jar -v silent -n")
- @memoize
def find_mbean(self, pattern, negative_pattern=None, domain='org.apache'):
"""
- Find mbean by specified pattern and domain on node.
+ Find mbean by specified pattern and domain on node. The lookup is
cached by this client, which
+ is safe as long as the client does not outlive the JVM it was built
for.
:param pattern: MBean name pattern.
:param negative_pattern: if passed used to filter out some MBeans
:param domain: Domain of MBean
:return: JmxMBean instance
"""
- cmd = "echo $'open %s\\n beans -d %s \\n close' | %s | grep -E -o
'%s'" \
- % (self.pid, domain, self.jmx_util_cmd, pattern)
+ key = (pattern, negative_pattern, domain)
+
+ if key not in self._mbeans:
+ cmd = "echo $'open %s\\n beans -d %s \\n close' | %s | grep -E -o
'%s'" \
+ % (self.pid, domain, self.jmx_util_cmd, pattern)
- if negative_pattern:
- cmd += " | grep -E -v '%s'" % negative_pattern
+ if negative_pattern:
+ cmd += " | grep -E -v '%s'" % negative_pattern
- name = next(self.__run_cmd(cmd)).strip()
+ self._mbeans[key] = JmxMBean(self,
next(self.__run_cmd(cmd)).strip())
- return JmxMBean(self, name)
+ return self._mbeans[key]
+
+ def find_metric_registry(self, registry):
+ """
+ :param registry: Metric registry name, e.g. ``cache.myCache`` - see
:func:`metric_registry_pattern`.
+ :return: JmxMBean of the metric registry.
+ """
+ return self.find_mbean(*metric_registry_pattern(registry))
def mbean_attribute(self, mbean, attr):
"""
@@ -188,31 +293,34 @@ class DiscoveryInfo:
class IgniteJmxMixin:
"""
Mixin to IgniteService node, exposing useful properties, obtained from JMX.
+
+ Everything here is read through the JMX client of the node's CURRENT JVM:
a client holds the
+ pid and caches the MBean names of the JVM it was built for, so
ignite_jmx_mixin() drops it on
+ every start of the node and the next access builds a new one.
"""
- @memoize
def jmx_client(self):
"""
- :return: JmxClient instance.
+ :return: JmxClient instance of the running node.
"""
- # noinspection PyTypeChecker
- return JmxClient(self)
+ if self._jmx_client is None:
+ # noinspection PyTypeChecker
+ self._jmx_client = JmxClient(self)
+
+ return self._jmx_client
- @memoize
def node_id(self):
"""
:return: Local node id.
"""
- return next(self.kernal_mbean().LocalNodeId).strip()
+ return self.kernal_mbean().value("LocalNodeId")
def discovery_info(self):
"""
:return: DiscoveryInfo instance.
"""
disco_mbean = self.disco_mbean()
- crd = next(disco_mbean.Coordinator).strip()
- local = next(disco_mbean.LocalNodeFormatted).strip()
- return DiscoveryInfo(crd, local)
+ return DiscoveryInfo(disco_mbean.value("Coordinator"),
disco_mbean.value("LocalNodeFormatted"))
def kernal_mbean(self):
"""
@@ -220,12 +328,18 @@ class IgniteJmxMixin:
"""
return
self.jmx_client().find_mbean('.*group=Kernal.*name=IgniteKernal')
- @memoize
+ def metric_registry_mbean(self, registry):
+ """
+ :param registry: Metric registry name, e.g. ``cache.myCache`` or
``cacheGroups.myGroup``.
+ :return: MBean of the metric registry.
+ """
+ return self.jmx_client().find_metric_registry(registry)
+
def disco_mbean(self):
"""
:return: DiscoverySpi MBean.
"""
- disco_spi = next(self.kernal_mbean().DiscoverySpiFormatted).strip()
+ disco_spi = self.kernal_mbean().value("DiscoverySpiFormatted")
if 'ZookeeperDiscoverySpi' in disco_spi:
return
self.jmx_client().find_mbean('.*group=SPIs.*name=ZookeeperDiscoverySpi')
diff --git a/modules/ducktests/tests/ignitetest/tests/dump_test.py
b/modules/ducktests/tests/ignitetest/tests/dump_test.py
index db58d506444..0a8bfcd4d69 100644
--- a/modules/ducktests/tests/ignitetest/tests/dump_test.py
+++ b/modules/ducktests/tests/ignitetest/tests/dump_test.py
@@ -115,8 +115,8 @@ class DumpTest(IgniteTest):
data_region_size = {}
for node in ignite.nodes:
- mbean =
node.jmx_client().find_mbean('.*group=io.*name="dataregion.default"')
- data_region_size[node.consistent_id] =
int(next(mbean.TotalUsedSize))
+ mbean = node.metric_registry_mbean('io.dataregion.default')
+ data_region_size[node.consistent_id] =
int(mbean.value("TotalUsedSize"))
return {
"data_region_size": data_region_size
diff --git a/modules/ducktests/tests/ignitetest/tests/rebalance/util.py
b/modules/ducktests/tests/ignitetest/tests/rebalance/util.py
index 9a5351dd238..282a8f4ce78 100644
--- a/modules/ducktests/tests/ignitetest/tests/rebalance/util.py
+++ b/modules/ducktests/tests/ignitetest/tests/rebalance/util.py
@@ -190,12 +190,12 @@ def get_rebalance_metrics(node, cache_group):
:param cache_group: Cache group.
:return: RebalanceMetrics instance.
"""
- mbean = node.jmx_client().find_mbean('.*group=cacheGroups.*name="%s"' %
cache_group)
- start_time = int(next(mbean.RebalancingStartTime))
- end_time = int(next(mbean.RebalancingEndTime))
+ mbean = node.metric_registry_mbean(f'cacheGroups.{cache_group}')
+ start_time = int(mbean.value("RebalancingStartTime"))
+ end_time = int(mbean.value("RebalancingEndTime"))
return RebalanceMetrics(
- received_bytes=int(next(mbean.RebalancingReceivedBytes)),
+ received_bytes=int(mbean.value("RebalancingReceivedBytes")),
start_time=start_time,
end_time=end_time,
duration=(end_time - start_time) if start_time != -1 and end_time !=
-1 else 0,