def test_discovered_host_labels_repr():
labels = DiscoveredHostLabels()
labels.add_label(HostLabel(u"äbc", u"123", "plugin_1"))
labels.add_label(HostLabel(u"ccc", u"ddd", "plugin_2"))
assert repr(
labels
) == "DiscoveredHostLabels(HostLabel('ccc', 'ddd', plugin_name='plugin_2'), HostLabel('äbc', '123', plugin_name='plugin_1'))"
def test_discovered_host_labels_repr():
labels = DiscoveredHostLabels()
labels.add_label(HostLabel(u"äbc", u"123", SectionName("plugin_1")))
labels.add_label(HostLabel(u"ccc", u"ddd", SectionName("plugin_2")))
assert repr(labels) == (
"DiscoveredHostLabels(" #
"HostLabel('ccc', 'ddd', plugin_name=SectionName('plugin_2')), " #
"HostLabel('äbc', '123', plugin_name=SectionName('plugin_1')))")
def test_discovered_host_labels_add():
labels_1 = DiscoveredHostLabels()
labels_1.add_label(HostLabel(u"äbc", u"123", "plugin_1"))
labels_2 = DiscoveredHostLabels()
labels_2.add_label(HostLabel(u"xyz", u"blä", "plugin_2"))
new_labels = labels_1 + labels_2
assert new_labels.to_dict() == {
u"äbc": {
"value": u"123",
"plugin_name": "plugin_1",
},
u"xyz": {
"value": u"blä",
"plugin_name": "plugin_2",
},
}
labels_1 += labels_2
assert labels_1.to_dict() == {
u"äbc": {
"value": u"123",
"plugin_name": "plugin_1",
},
u"xyz": {
"value": u"blä",
"plugin_name": "plugin_2",
},
}
def test_discovered_host_labels_store_save(discovered_host_labels_dir):
store = DiscoveredHostLabelsStore("host")
labels = DiscoveredHostLabels(HostLabel(u"xyz", u"äbc"))
label_dict = labels.to_dict()
assert not store.file_path.exists() # pylint: disable=no-member
store.save(label_dict)
assert store.file_path.exists() # pylint: disable=no-member
assert store.load() == label_dict
def test_discovered_host_labels_store_save(discovered_host_labels_dir):
store = DiscoveredHostLabelsStore("host")
labels = DiscoveredHostLabels(
HostLabel(u"xyz", u"äbc", SectionName("sectionname")))
label_dict = labels.to_dict()
assert not store.file_path.exists()
store.save(label_dict)
assert store.file_path.exists()
assert store.load() == label_dict
def test_discovered_host_labels_sub():
labels_1 = DiscoveredHostLabels()
labels_1.add_label(HostLabel("foo", "bär", SectionName("plugin_1")))
labels_1.add_label(HostLabel("foo2", "bär2", SectionName("plugin_2")))
labels_2 = DiscoveredHostLabels()
labels_2.add_label(HostLabel("foo", "bär", SectionName("plugin_1")))
assert (labels_1 - labels_2).to_dict() == {
"foo2": {
"value": "bär2",
"plugin_name": "plugin_2",
},
}
assert (labels_2 - labels_1).to_dict() == {}
def test_discovered_host_labels_path(discovered_host_labels_dir):
hostname = "test.host.de"
config.get_config_cache().initialize()
assert not (discovered_host_labels_dir / hostname).exists()
DiscoveredHostLabelsStore(hostname).save(
DiscoveredHostLabels(HostLabel("foo", "1.5")).to_dict())
assert (discovered_host_labels_dir / (hostname + ".mk")).exists()
class DiscoveryResult(object): # pylint: disable=useless-object-inheritance
"""
The result of the discovery as a whole.
Much like in the case of the check result, this also makes sure
that yield-based discovery functions run, and that no exceptions
get lost in the laziness.
"""
# TODO: Add some more consistency checks here.
def __init__(self, result=()):
self.entries = []
self.labels = DiscoveredHostLabels()
if not result:
# discovering nothing is valid!
return
for entry in result:
if isinstance(entry, DiscoveredHostLabels):
self.labels += entry
elif isinstance(entry, HostLabel):
self.labels.add_label(entry)
# preparation for ServiceLabel Discovery
#elif isinstance(entry, Service):
#
else:
self.entries.append(DiscoveryEntry(entry))
self.entries.sort(key=repr)
def __eq__(self, other):
return self.entries == other.entries and self.labels == other.labels
# TODO: Very questionable __repr__ conversion, leading to even more
# interesting typing Kung Fu...
def __repr__(self):
# type: () -> str
entries = [o for o in self.entries
if isinstance(o, object)] # type: List[object]
host_labels = [
HostLabel(six.text_type(k), six.text_type(self.labels[k]))
for k in self.labels
] # type: List[object]
return "DiscoveryResult(%r)" % (entries + host_labels, )
# TODO: Very obscure and inconsistent __str__ conversion...
def __str__(self):
return "%s%s" % (map(
tuple, self.entries), [self.labels[k].label for k in self.labels])
def __init__(self, result=()):
self.entries = []
self.labels = DiscoveredHostLabels()
if not result:
# discovering nothing is valid!
return
for entry in result:
if isinstance(entry, DiscoveredHostLabels):
self.labels += entry
elif isinstance(entry, HostLabel):
self.labels.add_label(entry)
# preparation for ServiceLabel Discovery
#elif isinstance(entry, Service):
#
else:
self.entries.append(DiscoveryEntry(entry))
self.entries.sort(key=repr)
def __init__(self,
item: Item,
parameters: LegacyCheckParameters = None,
service_labels: DiscoveredServiceLabels = None,
host_labels: DiscoveredHostLabels = None) -> None:
self.item = item
self.parameters = parameters
self.service_labels = service_labels or DiscoveredServiceLabels()
self.host_labels = host_labels or DiscoveredHostLabels()
def __init__(self,
item,
parameters=None,
service_labels=None,
host_labels=None):
# type: (Item, CheckParameters, DiscoveredServiceLabels, DiscoveredHostLabels) -> None
self.item = item
self.parameters = parameters
self.service_labels = service_labels or DiscoveredServiceLabels()
self.host_labels = host_labels or DiscoveredHostLabels()
def old_school_discover_function(parsed_extra):
_parsed, _extra_section = parsed_extra
yield "item1", {"discoverd_param": 42}
yield HOST_LABELS[0]
yield Service(
"item2",
{},
host_labels=DiscoveredHostLabels(*HOST_LABELS[1:]),
)
yield "item3", "{'how_bad_is_this': 100}"
class DiscoveryResult(object):
"""
The result of the discovery as a whole.
Much like in the case of the check result, this also makes sure
that yield-based discovery functions run, and that no exceptions
get lost in the laziness.
"""
# TODO: Add some more consistency checks here.
def __init__(self, result=()):
self.entries = []
self.labels = DiscoveredHostLabels()
if not result:
# discovering nothing is valid!
return
for entry in result:
if isinstance(entry, DiscoveredHostLabels):
self.labels += entry
elif isinstance(entry, HostLabel):
self.labels.add_label(entry)
# preparation for ServiceLabel Discovery
#elif isinstance(entry, Service):
#
else:
self.entries.append(DiscoveryEntry(entry))
self.entries.sort(key=repr)
def __eq__(self, other):
return self.entries == other.entries and self.labels == other.labels
def __repr__(self):
args = self.entries + [
HostLabel(six.text_type(k), six.text_type(self.labels[k]))
for k in self.labels
]
return "DiscoveryResult(%r)" % (args, )
def __str__(self):
return "%s%s" % (map(
tuple, self.entries), [self.labels[k].label for k in self.labels])
def test_discovered_host_labels_from_dict():
label_dict = {
u"äbc": {
"value": u"123",
"plugin_name": "plugin_1",
},
u"xyz": {
"value": u"blä",
"plugin_name": "plugin_2",
},
}
labels = DiscoveredHostLabels.from_dict(label_dict)
assert labels.to_dict() == label_dict
def test_perform_host_label_discovery(discovered_host_labels_dir,
existing_labels, new_labels,
expected_labels, load_labels):
hostname = "testhost"
config.get_config_cache().initialize()
store = DiscoveredHostLabelsStore(hostname)
store.save(
DiscoveredHostLabels(*[HostLabel(*x)
for x in existing_labels]).to_dict())
discovery_parameters = DiscoveryParameters(
on_error="raise",
load_labels=load_labels,
save_labels=False,
)
new_host_labels, _host_labels_per_plugin = _perform_host_label_discovery(
hostname, DiscoveredHostLabels(*[HostLabel(*x) for x in new_labels]),
discovery_parameters)
labels_expected = DiscoveredHostLabels(
*[HostLabel(*x) for x in expected_labels])
assert new_host_labels.to_dict() == labels_expected.to_dict()
def test_discovered_host_labels_to_list():
labels = DiscoveredHostLabels()
assert labels.to_list() == []
labels.add_label(HostLabel(u"äbc", u"123", "plugin_1"))
labels.add_label(HostLabel(u"xyz", u"blä", "plugin_2"))
assert labels.to_list() == [
HostLabel(u"xyz", u"blä", "plugin_2"),
HostLabel(u"äbc", u"123", "plugin_1")
]
def test_discovered_host_labels_to_list():
labels = DiscoveredHostLabels()
assert labels.to_list() == []
labels.add_label(HostLabel("äbc", "123", SectionName("plugin_1")))
labels.add_label(HostLabel("xyz", "blä", SectionName("plugin_2")))
assert labels.to_list() == [
HostLabel("xyz", "blä", SectionName("plugin_2")),
HostLabel("äbc", "123", SectionName("plugin_1")),
]
def test_host_labels_ps_no_match_pattern():
section = (
1,
[
(
ps.ps_info("(root,4056,1512,0.0/52-04:56:05,5689)".split()
), # type: ignore[call-arg]
["/usr/lib/ssh/sshd"],
),
])
params = [
Parameters({
"default_params": {},
"descr": "SSH",
"match": "~wat?",
"label": DiscoveredHostLabels(HostLabel(u'marco', u'polo')),
}),
Parameters({}),
]
assert list(ps.host_labels_ps(params, section)) == []
def test_discovered_host_labels_to_dict():
labels = DiscoveredHostLabels()
assert labels.to_dict() == {}
labels.add_label(HostLabel("äbc", "123", SectionName("plugin_1")))
labels.add_label(HostLabel("xyz", "blä", SectionName("plugin_2")))
assert labels.to_dict() == {
"äbc": {
"value": "123",
"plugin_name": "plugin_1",
},
"xyz": {
"value": "blä",
"plugin_name": "plugin_2",
},
}
def test_discovered_host_labels_to_dict():
labels = DiscoveredHostLabels()
assert labels.to_dict() == {}
labels.add_label(HostLabel(u"äbc", u"123", "plugin_1"))
labels.add_label(HostLabel(u"xyz", u"blä", "plugin_2"))
assert labels.to_dict() == {
u"äbc": {
"value": u"123",
"plugin_name": "plugin_1",
},
u"xyz": {
"value": u"blä",
"plugin_name": "plugin_2",
},
}
def test_subset_patterns(check_manager):
check = check_manager.get_check("ps")
check.set_check_api_utils_globals() # needed for host name
parsed = check.context['parse_ps'](
splitter("""(user,0,0,0.5) main
(user,0,0,0.4) main_dev
(user,0,0,0.1) main_dev
(user,0,0,0.5) main_test"""))[1]
# Boundary in match is necessary otherwise main instance accumulates all
wato_rule = [({
'default_params': {
'cpu_rescale_max': True,
'levels': (1, 1, 99999, 99999)
},
'match': '~(main.*)\\b',
'descr': '%s'
}, [], ["@all"], {})]
discovered = [
('main', {
'cpu_rescale_max': True,
'levels': (1, 1, 99999, 99999),
'process': '~(main.*)\\b',
'match_groups': ('main',),
'user': None,
'cgroup': (None, False),
}),
('main_dev', {
'cpu_rescale_max': True,
'levels': (1, 1, 99999, 99999),
'process': '~(main.*)\\b',
'match_groups': ('main_dev',),
'user': None,
'cgroup': (None, False),
}),
('main_test', {
'cpu_rescale_max': True,
'levels': (1, 1, 99999, 99999),
'process': '~(main.*)\\b',
'match_groups': ('main_test',),
'user': None,
'cgroup': (None, False),
}),
DiscoveredHostLabels(),
DiscoveredHostLabels(),
DiscoveredHostLabels(),
]
assert check.context["inventory_ps_common"](wato_rule, parsed) == discovered
def counted_reference(count):
return CheckResult([
(0, "%s process%s" % (count, '' if count == 1 else 'es'), [("count", count, 100000,
100000, 0, None)]),
(0, "0.5% CPU", [("pcpu", 0.5, None, None, None, None)]),
])
for (item, params), count in zip(discovered, [1, 2, 1]):
output = CheckResult(check.context["check_ps_common"](item, params, parsed, cpu_cores=1))
assertCheckResultsEqual(output, counted_reference(count))
"process_info": "text"
},
"match": "~.*(fire)fox",
"descr": "firefox is on %s",
"user": None,
}, [], ["@all"], {
"description": u"Firefox"
}),
({
"default_params": {
"process_info": "text"
},
"match": "~.*(fire)fox",
"descr": "firefox is on %s",
"user": None,
"label": DiscoveredHostLabels(HostLabel(u'marco', u'polo'), HostLabel(u'peter', u'pan')),
}, [], ["@all"], {
"description": u"Firefox with host labels"
}),
({
"default_params": {
"cpu_rescale_max": True,
"cpu_average": 15,
"process_info": "html",
"resident_levels_perc": (25.0, 50.0),
"virtual_levels": (1024**3, 2 * 1024**3),
"resident_levels": (1024**3, 2 * 1024**3),
"icon": "emacs.png",
},
"descr": "emacs %u",
"match": "emacs",
"cpu_rescale_max": "cpu_rescale_max_unspecified",
"process_info": "text"
},
"match": "~.*(fire)fox",
"descr": "firefox is on %s",
"user": None,
},
{
"default_params": {
"cpu_rescale_max": "cpu_rescale_max_unspecified",
"process_info": "text"
},
"match": "~.*(fire)fox",
"descr": "firefox is on %s",
"user": None,
"label": DiscoveredHostLabels(HostLabel(u'marco', u'polo'), HostLabel(u'peter', u'pan')),
},
{
"default_params": {
"cpu_rescale_max": True,
"cpu_average": 15,
"process_info": "html",
"resident_levels_perc": (25.0, 50.0),
"virtual_levels": (1024**3, 2 * 1024**3),
"resident_levels": (1024**3, 2 * 1024**3),
"icon": "emacs.png",
},
"descr": "emacs %u",
"match": "emacs",
"user": False
},
def test_get_discovery_specs():
assert ps.get_discovery_specs([
{
"default_params": {
"cpu_rescale_max": "cpu_rescale_max_unspecified"
},
"descr": "smss",
"match": "~smss.exe",
},
{
"default_params": {
"cpu_rescale_max": "cpu_rescale_max_unspecified",
"cpulevels": (90.0, 98.0),
"handle_count": (1000, 2000),
"levels": (1, 1, 99999, 99999),
"max_age": (3600, 7200),
"resident_levels": (104857600, 209715200),
"resident_levels_perc": (25.0, 50.0),
"single_cpulevels": (90.0, 98.0),
"virtual_levels": (1073741824000, 2147483648000),
},
"descr": "svchost",
"match": "svchost.exe",
},
{
"default_params": {
"cpu_rescale_max": "cpu_rescale_max_unspecified",
"process_info": "text",
},
"match": "~.*(fire)fox",
"descr": "firefox is on %s",
"user": None,
},
{
"default_params": {
"cpu_rescale_max": "cpu_rescale_max_unspecified",
"process_info": "text",
},
"match": "~.*(fire)fox",
"descr": "firefox is on %s",
"user": None,
"label": TEST_LABELS,
},
{
"default_params": {
"cpu_rescale_max": True,
"cpu_average": 15,
"process_info": "html",
"resident_levels_perc": (25.0, 50.0),
"virtual_levels": (1024**3, 2 * 1024**3),
"resident_levels": (1024**3, 2 * 1024**3),
"icon": "emacs.png",
},
"descr": "emacs %u",
"match": "emacs",
"user": False,
},
{
"default_params": {
"cpu_rescale_max": "cpu_rescale_max_unspecified",
"max_age": (3600, 7200),
"resident_levels_perc": (25.0, 50.0),
"single_cpulevels": (90.0, 98.0),
"resident_levels": (104857600, 209715200),
},
"match": "~.*cron",
"descr": "cron",
"user": "******",
},
{
"default_params": {
"cpu_rescale_max": "cpu_rescale_max_unspecified"
},
"descr": "sshd",
"match": "~.*sshd",
},
{
"default_params": {
"cpu_rescale_max": "cpu_rescale_max_unspecified"
},
"descr": "PS counter",
"user": "******",
},
{
"default_params": {
"cpu_rescale_max": "cpu_rescale_max_unspecified",
"process_info": "text",
},
"match": r"~/omd/sites/(\w+)/lib/cmc/checkhelper",
"descr": "Checkhelpers %s",
"user": None,
},
{
"default_params": {
"cpu_rescale_max": "cpu_rescale_max_unspecified",
"process_info": "text",
},
"match": r"~/omd/sites/\w+/lib/cmc/checkhelper",
"descr": "Checkhelpers Overall",
"user": None,
},
{
"descr": "cron",
"match": "/usr/sbin/cron",
"user": None,
"default_params": {
"cpu_rescale_max": "cpu_rescale_max_unspecified",
"levels": (1, 1, 20, 20),
},
},
{},
]) == [
(
"smss",
"~smss.exe",
None,
(None, False),
DiscoveredHostLabels(),
{
"cpu_rescale_max": "cpu_rescale_max_unspecified"
},
),
(
"svchost",
"svchost.exe",
None,
(None, False),
{},
{
"cpulevels": (90.0, 98.0),
"cpu_rescale_max": "cpu_rescale_max_unspecified",
"handle_count": (1000, 2000),
"levels": (1, 1, 99999, 99999),
"max_age": (3600, 7200),
"resident_levels": (104857600, 209715200),
"resident_levels_perc": (25.0, 50.0),
"single_cpulevels": (90.0, 98.0),
"virtual_levels": (1073741824000, 2147483648000),
},
),
(
"firefox is on %s",
"~.*(fire)fox",
None,
(None, False),
{},
{
"process_info": "text",
"cpu_rescale_max": "cpu_rescale_max_unspecified",
},
),
(
"firefox is on %s",
"~.*(fire)fox",
None,
(None, False),
TEST_LABELS,
{
"process_info": "text",
"cpu_rescale_max": "cpu_rescale_max_unspecified",
},
),
(
"emacs %u",
"emacs",
False,
(None, False),
{},
{
"cpu_average": 15,
"cpu_rescale_max": True,
"process_info": "html",
"resident_levels_perc": (25.0, 50.0),
"virtual_levels": (1024**3, 2 * 1024**3),
"resident_levels": (1024**3, 2 * 1024**3),
"icon": "emacs.png",
},
),
(
"cron",
"~.*cron",
"root",
(None, False),
{},
{
"max_age": (3600, 7200),
"cpu_rescale_max": "cpu_rescale_max_unspecified",
"resident_levels_perc": (25.0, 50.0),
"single_cpulevels": (90.0, 98.0),
"resident_levels": (104857600, 209715200),
},
),
(
"sshd",
"~.*sshd",
None,
(None, False),
{},
{
"cpu_rescale_max": "cpu_rescale_max_unspecified"
},
),
(
"PS counter",
None,
"zombie",
(None, False),
{},
{
"cpu_rescale_max": "cpu_rescale_max_unspecified"
},
),
(
"Checkhelpers %s",
r"~/omd/sites/(\w+)/lib/cmc/checkhelper",
None,
(None, False),
{},
{
"process_info": "text",
"cpu_rescale_max": "cpu_rescale_max_unspecified",
},
),
(
"Checkhelpers Overall",
r"~/omd/sites/\w+/lib/cmc/checkhelper",
None,
(None, False),
{},
{
"process_info": "text",
"cpu_rescale_max": "cpu_rescale_max_unspecified",
},
),
(
"cron",
"/usr/sbin/cron",
None,
(None, False),
{},
{
"cpu_rescale_max": "cpu_rescale_max_unspecified",
"levels": (1, 1, 20, 20),
},
),
]
# conditions defined in the file COPYING, which is part of this source code package.
import pytest # type: ignore[import]
from cmk.base.discovered_labels import DiscoveredHostLabels
from cmk.base.plugins.agent_based.agent_based_api.v1 import HostLabel, type_defs
from cmk.base.plugins.agent_based.utils import ps
pytestmark = pytest.mark.checks
TEST_LABELS = DiscoveredHostLabels.from_dict({
"marco": {
"value": "polo",
"plugin_name": None
},
"peter": {
"value": "pan",
"plugin_name": None
}
})
def test_get_discovery_specs():
assert ps.get_discovery_specs([
{
"default_params": {
'cpu_rescale_max': 'cpu_rescale_max_unspecified'
},
"descr": "smss",
"match": "~smss.exe"
},
def labels(request):
if request.param == "host":
return DiscoveredHostLabels()
return DiscoveredServiceLabels()
def get_check_preview(
*,
host_name: HostName,
max_cachefile_age: int,
use_cached_snmp_data: bool,
on_error: str,
) -> Tuple[CheckPreviewTable, DiscoveredHostLabels]:
"""Get the list of service of a host or cluster and guess the current state of
all services if possible"""
config_cache = config.get_config_cache()
host_config = config_cache.get_host_config(host_name)
ip_address = None if host_config.is_cluster else config.lookup_ip_address(host_config)
discovery_parameters = DiscoveryParameters(
on_error=on_error,
load_labels=False,
save_labels=False,
only_host_labels=False,
)
_set_cache_opts_of_checkers(use_cached_snmp_data=use_cached_snmp_data)
nodes = sources.make_nodes(
config_cache, host_config, ip_address, Mode.DISCOVERY,
sources.make_sources(
host_config,
ip_address,
mode=Mode.DISCOVERY,
on_scan_error=on_error,
))
parsed_sections_broker = ParsedSectionsBroker()
sources.update_host_sections(
parsed_sections_broker,
nodes,
max_cachefile_age=max_cachefile_age,
host_config=host_config,
fetcher_messages=list(
sources.fetch_all(
nodes,
max_cachefile_age=max_cachefile_age,
host_config=host_config,
)),
selected_sections=NO_SELECTION,
)
grouped_services, host_label_result = _get_host_services(
host_config,
ip_address,
parsed_sections_broker,
discovery_parameters,
)
table: CheckPreviewTable = []
for check_source, services_with_nodes in grouped_services.items():
for service, found_on_nodes in services_with_nodes:
plugin = agent_based_register.get_check_plugin(service.check_plugin_name)
params = _preview_params(host_name, service, plugin, check_source)
if check_source in ['legacy', 'active', 'custom']:
exitcode = None
output = u"WAITING - %s check, cannot be done offline" % check_source.title()
ruleset_name: Optional[RulesetName] = None
else:
ruleset_name = (str(plugin.check_ruleset_name)
if plugin and plugin.check_ruleset_name else None)
wrapped_params = (Parameters(wrap_parameters(params)) if plugin and
plugin.check_default_parameters is not None else None)
exitcode, output, _perfdata = checking.get_aggregated_result(
parsed_sections_broker,
host_config,
ip_address,
service,
plugin,
lambda p=wrapped_params: p, # type: ignore[misc] # "type of lambda"
).result
# Service discovery never uses the perfdata in the check table. That entry
# is constantly discarded, yet passed around(back and forth) as part of the
# discovery result in the request elements. Some perfdata VALUES are not parsable
# by ast.literal_eval such as "inf" it lead to ValueErrors. Thus keep perfdata empty
perfdata: List[MetricTuple] = []
table.append((
_preview_check_source(host_name, service, check_source),
str(service.check_plugin_name),
ruleset_name,
service.item,
service.parameters,
params,
service.description,
exitcode,
output,
perfdata,
service.service_labels.to_dict(),
found_on_nodes,
))
return table, DiscoveredHostLabels(
*{
# TODO (mo): According to unit tests, this is what was done prior to refactoring.
# Im not sure this is desired. If it is, it should be explained.
**{l.name: l for l in host_label_result.vanished},
**{l.name: l for l in host_label_result.present},
}.values())
def test_get_discovery_specs():
assert ps.get_discovery_specs([
{
"default_params": {},
"descr": "smss",
"match": "~smss.exe"
},
{
"default_params": {
"cpulevels": (90.0, 98.0),
"handle_count": (1000, 2000),
"levels": (1, 1, 99999, 99999),
"max_age": (3600, 7200),
"resident_levels": (104857600, 209715200),
"resident_levels_perc": (25.0, 50.0),
"single_cpulevels": (90.0, 98.0),
"virtual_levels": (1073741824000, 2147483648000),
},
"descr": "svchost",
"match": "svchost.exe"
},
{
"default_params": {
"process_info": "text"
},
"match": "~.*(fire)fox",
"descr": "firefox is on %s",
"user": None,
},
{
"default_params": {
"process_info": "text"
},
"match": "~.*(fire)fox",
"descr": "firefox is on %s",
"user": None,
"label": DiscoveredHostLabels(HostLabel(u'marco', u'polo'), HostLabel(u'peter',
u'pan')),
},
{
"default_params": {
"cpu_rescale_max": True,
"cpu_average": 15,
"process_info": "html",
"resident_levels_perc": (25.0, 50.0),
"virtual_levels": (1024**3, 2 * 1024**3),
"resident_levels": (1024**3, 2 * 1024**3),
"icon": "emacs.png",
},
"descr": "emacs %u",
"match": "emacs",
"user": False
},
{
"default_params": {
"max_age": (3600, 7200),
"resident_levels_perc": (25.0, 50.0),
"single_cpulevels": (90.0, 98.0),
"resident_levels": (104857600, 209715200),
},
"match": "~.*cron",
"descr": "cron",
"user": "******"
},
{
"default_params": {},
"descr": "sshd",
"match": "~.*sshd"
},
{
'default_params': {},
'descr': 'PS counter',
'user': '******',
},
{
"default_params": {
"process_info": "text"
},
"match": r"~/omd/sites/(\w+)/lib/cmc/checkhelper",
"descr": "Checkhelpers %s",
"user": None,
},
{
"default_params": {
"process_info": "text"
},
"match": r"~/omd/sites/\w+/lib/cmc/checkhelper",
"descr": "Checkhelpers Overall",
"user": None,
},
{},
]) == [
("smss", "~smss.exe", None, (None, False), DiscoveredHostLabels(), {
'cpu_rescale_max': None
}),
("svchost", "svchost.exe", None, (None, False), {}, {
"cpulevels": (90.0, 98.0),
'cpu_rescale_max': None,
"handle_count": (1000, 2000),
"levels": (1, 1, 99999, 99999),
"max_age": (3600, 7200),
"resident_levels": (104857600, 209715200),
"resident_levels_perc": (25.0, 50.0),
"single_cpulevels": (90.0, 98.0),
"virtual_levels": (1073741824000, 2147483648000),
}),
("firefox is on %s", "~.*(fire)fox", None, (None, False), {}, {
"process_info": "text",
'cpu_rescale_max': None,
}),
("firefox is on %s", "~.*(fire)fox", None, (None, False),
DiscoveredHostLabels(HostLabel(u'marco', u'polo'), HostLabel(u'peter', u'pan')), {
"process_info": "text",
'cpu_rescale_max': None,
}),
("emacs %u", "emacs", False, (None, False), {}, {
"cpu_average": 15,
'cpu_rescale_max': True,
"process_info": "html",
"resident_levels_perc": (25.0, 50.0),
"virtual_levels": (1024**3, 2 * 1024**3),
"resident_levels": (1024**3, 2 * 1024**3),
"icon": "emacs.png",
}),
("cron", "~.*cron", "root", (None, False), {}, {
"max_age": (3600, 7200),
'cpu_rescale_max': None,
"resident_levels_perc": (25.0, 50.0),
"single_cpulevels": (90.0, 98.0),
"resident_levels": (104857600, 209715200)
}),
("sshd", "~.*sshd", None, (None, False), {}, {
'cpu_rescale_max': None
}),
('PS counter', None, 'zombie', (None, False), {}, {
'cpu_rescale_max': None
}),
("Checkhelpers %s", r"~/omd/sites/(\w+)/lib/cmc/checkhelper", None, (None, False), {}, {
"process_info": "text",
'cpu_rescale_max': None,
}),
("Checkhelpers Overall", r"~/omd/sites/\w+/lib/cmc/checkhelper", None, (None, False), {}, {
"process_info": "text",
'cpu_rescale_max': None,
}),
]
