def test_get_cmk_passive_service_attributes(monkeypatch, hostname, result):
ts = Scenario()
ts.add_host("localhost")
ts.add_host("blub")
ts.set_option(
"extra_service_conf",
{
"contact_groups": [
("ding", ["localhost"], ["CPU load$"]),
],
"check_interval": [
(40.0, ["blub"], ["Check_MK$"]),
(33.0, ["localhost"], ["CPU load$"]),
],
},
)
config_cache = ts.apply(monkeypatch)
host_config = config_cache.get_host_config(hostname)
check_mk_attrs = core_config.get_service_attributes(
hostname, "Check_MK", config_cache)
service = ConfiguredService(
check_plugin_name=CheckPluginName("cpu_loads"),
item=None,
description="CPU load",
parameters=TimespecificParameters(),
discovered_parameters={},
service_labels={},
)
service_spec = core_config.get_cmk_passive_service_attributes(
config_cache, host_config, service, check_mk_attrs)
assert service_spec == result
def test_mgmt_config_ruleset_order(monkeypatch, protocol, cred_attribute,
folder_credentials, ruleset_credentials):
ts = Scenario()
ts.set_ruleset(
"management_board_config",
[
{
"condition": {},
"options": {},
"value": ("snmp", "RULESET1"),
},
{
"condition": {},
"options": {},
"value": ("snmp", "RULESET2"),
},
],
)
ts.add_host("mgmt-host", host_path="/wato/folder1/hosts.mk")
ts.set_option("ipaddresses", {"mgmt-host": "127.0.0.1"})
ts.set_option("management_protocol", {"mgmt-host": "snmp"})
config_cache = ts.apply(monkeypatch)
host_config = config_cache.get_host_config("mgmt-host")
assert host_config.has_management_board
assert host_config.management_protocol == "snmp"
assert host_config.management_address == "127.0.0.1"
assert host_config.management_credentials == "RULESET1"
def test_mgmt_board_ip_addresses(
monkeypatch,
protocol,
cred_attribute,
credentials,
tags,
host_attributes,
ipaddresses,
ipv6addresses,
ip_address_result,
):
hostname = "mgmt-host"
ts = Scenario()
ts.add_host(hostname, tags=tags)
ts.set_option("host_attributes", {hostname: host_attributes})
ts.set_option("ipaddresses", ipaddresses)
ts.set_option("ipv6addresses", ipv6addresses)
ts.set_option("management_protocol", {hostname: protocol})
ts.set_option(cred_attribute, {hostname: credentials})
config_cache = ts.apply(monkeypatch)
host_config = config_cache.get_host_config(hostname)
assert host_config.has_management_board
assert host_config.management_protocol == protocol
assert host_config.management_address == ip_address_result
assert host_config.management_credentials == credentials
def test_get_check_table__static_checks_win(monkeypatch: MonkeyPatch) -> None:
hostname_str = "df_host"
hostname = HostName(hostname_str)
plugin_name = CheckPluginName("df")
item = "/snap/core/9066"
ts = Scenario()
ts.add_host(hostname)
ts.set_option(
"static_checks",
{
"filesystem": [
((str(plugin_name), item, {
"source": "static"
}), [], [hostname_str]),
],
},
)
ts.set_autochecks(
hostname_str,
[AutocheckEntry(plugin_name, item, {"source": "auto"}, {})])
ts.apply(monkeypatch)
chk_table = check_table.get_check_table(hostname)
# assert check table is populated as expected
assert len(chk_table) == 1
# assert static checks won
effective_params = chk_table[(plugin_name,
item)].parameters.evaluate(lambda _: True)
assert effective_params[
"source"] == "static" # type: ignore[index,call-overload]
def make_scenario(hostname, tags):
ts = Scenario().add_host(hostname, tags=tags)
ts.set_ruleset(
"datasource_programs",
[
("echo 1", [], ["ds-host-14", "all-agents-host", "all-special-host"], {}),
],
)
ts.set_option(
"special_agents",
{
"jolokia": [
(
{},
[],
[
"special-host-14",
"all-agents-host",
"all-special-host",
],
{},
),
]
},
)
return ts
def test_attribute_defaults(self, monkeypatch):
hostname = "testhost"
ipaddress = "1.2.3.4"
ts = Scenario()
ts.add_host(hostname)
ts.set_option("management_protocol", {hostname: "snmp"})
ts.set_option(
"host_attributes",
{
hostname: {
"management_address": ipaddress
},
},
)
ts.apply(monkeypatch)
source = SNMPSource.management_board(
HostName(hostname),
ipaddress,
force_cache_refresh=False,
selected_sections=NO_SELECTION,
on_scan_error=OnError.RAISE,
)
assert source.description == (
"Management board - SNMP "
"(Community: 'public', Bulk walk: no, Port: 161, Backend: Classic)"
)
def test_analyse_host(monkeypatch):
automation = automations.AutomationAnalyseHost()
ts = Scenario()
ts.add_host("test-host")
ts.set_option(
"host_labels",
{
"test-host": {
"explicit": "ding",
},
},
)
ts.apply(monkeypatch)
assert automation.execute(["test-host"]) == AnalyseHostResult(
label_sources={
"cmk/site": "discovered",
"explicit": "explicit"
},
labels={
"cmk/site": "NO_SITE",
"explicit": "ding"
},
)
def test_compile_delayed_host_check(monkeypatch: MonkeyPatch,
config_path: VersionedConfigPath) -> None:
hostname = HostName("localhost")
ts = Scenario()
ts.add_host(hostname)
ts.set_option("delay_precompile", True)
config_cache = ts.apply(monkeypatch)
# Ensure a host check is created
monkeypatch.setattr(
core_nagios,
"_get_needed_plugin_names",
lambda c: (set(), {CheckPluginName("uptime")}, set()),
)
source_file = core_nagios.HostCheckStore.host_check_source_file_path(
config_path,
hostname,
)
compiled_file = core_nagios.HostCheckStore.host_check_file_path(
config_path, hostname)
assert config.delay_precompile is True
assert not source_file.exists()
assert not compiled_file.exists()
# Write the host check source file
host_check = core_nagios._dump_precompiled_hostcheck(
config_cache,
config_path,
hostname,
verify_site_python=False,
)
assert host_check is not None
core_nagios.HostCheckStore().write(config_path, hostname, host_check)
# The compiled file path links to the source file until it has been executed for the first
# time. Then the symlink is replaced with the compiled file
assert source_file.exists()
assert compiled_file.exists()
assert compiled_file.resolve() == source_file
# Expect the command to fail: We don't have the correct environment to execute it.
# But this is no problem for our test, we only want to see the result of the compilation.
assert (subprocess.run(
["python3", str(compiled_file)],
shell=False,
close_fds=True,
check=False,
).returncode == 1)
assert compiled_file.resolve() != source_file
with compiled_file.open("rb") as f:
assert f.read().startswith(importlib.util.MAGIC_NUMBER)
def test_get_check_table_of_mgmt_boards(
monkeypatch: MonkeyPatch, hostname_str: str,
expected_result: List[ServiceID]) -> None:
hostname = HostName(hostname_str)
autochecks: Mapping[str, Sequence[Service[LegacyCheckParameters]]] = {
"mgmt-board-ipmi": [
Service(
CheckPluginName("mgmt_ipmi_sensors"),
"TEMP X",
"Management Interface: IPMI Sensor TEMP X",
{},
),
],
"ipmi-host": [
Service(CheckPluginName("ipmi_sensors"), "TEMP Y",
"IPMI Sensor TEMP Y", {}),
],
}
ts = Scenario().add_host(
"mgmt-board-ipmi",
tags={
"piggyback": "auto-piggyback",
"networking": "lan",
"address_family": "no-ip",
"criticality": "prod",
"snmp_ds": "no-snmp",
"site": "heute",
"agent": "no-agent",
},
)
ts.add_host(
"ipmi-host",
tags={
"piggyback": "auto-piggyback",
"networking": "lan",
"agent": "cmk-agent",
"criticality": "prod",
"snmp_ds": "no-snmp",
"site": "heute",
"address_family": "ip-v4-only",
},
)
ts.set_option("management_protocol", {"mgmt-board-ipmi": "ipmi"})
config_cache = ts.apply(monkeypatch)
monkeypatch.setattr(config_cache, "get_autochecks_of",
lambda h: autochecks.get(h, []))
assert list(
check_table.get_check_table(hostname).keys()) == expected_result
def test_get_check_table_of_mgmt_boards(
monkeypatch: MonkeyPatch, hostname_str: str,
expected_result: List[ServiceID]) -> None:
hostname = HostName(hostname_str)
ts = Scenario()
ts.add_host(
"mgmt-board-ipmi",
tags={
"piggyback": "auto-piggyback",
"networking": "lan",
"address_family": "no-ip",
"criticality": "prod",
"snmp_ds": "no-snmp",
"site": "heute",
"agent": "no-agent",
},
)
ts.add_host(
"ipmi-host",
tags={
"piggyback": "auto-piggyback",
"networking": "lan",
"agent": "cmk-agent",
"criticality": "prod",
"snmp_ds": "no-snmp",
"site": "heute",
"address_family": "ip-v4-only",
},
)
ts.set_option("management_protocol", {"mgmt-board-ipmi": "ipmi"})
ts.set_autochecks(
"mgmt-board-ipmi",
[
AutocheckEntry(CheckPluginName("mgmt_ipmi_sensors"), "TEMP X", {},
{})
],
)
ts.set_autochecks(
"ipmi-host",
[AutocheckEntry(CheckPluginName("ipmi_sensors"), "TEMP Y", {}, {})],
)
ts.apply(monkeypatch)
assert list(
check_table.get_check_table(hostname).keys()) == expected_result
def test_tcpdatasource_restricted_address_mismatch(
monkeypatch,
restricted_address_mismatch_state,
only_from,
rule,
res,
):
# TODO(ml): Not only is this white box testing but all these instantiations
# before the summarizer obscure the purpose of the test. This is
# way too complicated. Test the `AgentSummarizerDefault` directly
# in `tests.unit.cmk.core_helpers.test_summarizers` instead.
hostname = HostName("hostname")
ts = Scenario().add_host(hostname)
ts.set_option("agent_config",
{"only_from": [(rule, [], [str(hostname)], {})]})
if restricted_address_mismatch_state is not None:
ts.set_ruleset(
"check_mk_exit_status",
[
(
{
"restricted_address_mismatch":
restricted_address_mismatch_state,
},
[],
[str(hostname)],
{},
),
],
)
ts.apply(monkeypatch)
source = TCPSource(hostname, "ipaddress")
summarizer = AgentSummarizerDefault(
source.exit_spec,
is_cluster=source.host_config.is_cluster,
agent_min_version=0,
agent_target_version=source.host_config.agent_target_version,
only_from=source.host_config.only_from,
)
assert summarizer._check_only_from(only_from) == res
def test_get_host_attributes(fixup_ip_lookup, monkeypatch):
ts = Scenario()
ts.add_host("test-host", tags={"agent": "no-agent"})
ts.set_option(
"host_labels",
{
"test-host": {
"ding": "dong",
},
},
)
config_cache = ts.apply(monkeypatch)
expected_attrs = {
"_ADDRESSES_4": "",
"_ADDRESSES_6": "",
"_ADDRESS_4": "0.0.0.0",
"_ADDRESS_6": "",
"_ADDRESS_FAMILY": "4",
"_FILENAME": "/wato/hosts.mk",
"_TAGS":
"/wato/ auto-piggyback ip-v4 ip-v4-only lan no-agent no-snmp prod site:unit",
"__TAG_address_family": "ip-v4-only",
"__TAG_agent": "no-agent",
"__TAG_criticality": "prod",
"__TAG_ip-v4": "ip-v4",
"__TAG_networking": "lan",
"__TAG_piggyback": "auto-piggyback",
"__TAG_site": "unit",
"__TAG_snmp_ds": "no-snmp",
"__LABEL_ding": "dong",
"__LABEL_cmk/site": "NO_SITE",
"__LABELSOURCE_cmk/site": "discovered",
"__LABELSOURCE_ding": "explicit",
"address": "0.0.0.0",
"alias": "test-host",
}
if cmk_version.is_managed_edition():
expected_attrs["_CUSTOMER"] = "provider"
attrs = core_config.get_host_attributes("test-host", config_cache)
assert attrs == expected_attrs
def test_tcpdatasource_only_from(monkeypatch, res, reported, rule):
# TODO(ml): Not only is this white box testing but all these instantiations
# before the summarizer obscure the purpose of the test. This is
# way too complicated. Test the `AgentSummarizerDefault` directly
# in `tests.unit.cmk.core_helpers.test_summarizers` instead.
ts = Scenario().add_host("hostname")
ts.set_option("agent_config", {"only_from": [rule]} if rule else {})
config_cache = ts.apply(monkeypatch)
source = TCPSource(HostName("hostname"), "ipaddress")
monkeypatch.setattr(config_cache, "host_extra_conf",
lambda host, ruleset: ruleset)
summarizer = AgentSummarizerDefault(
source.exit_spec,
is_cluster=source.host_config.is_cluster,
agent_min_version=0,
agent_target_version=source.host_config.agent_target_version,
only_from=source.host_config.only_from,
)
assert summarizer._check_only_from(reported) == res
def test_mgmt_config_ruleset_overidden_by_explicit_setting(
monkeypatch, protocol, cred_attribute, host_credentials,
ruleset_credentials):
ts = Scenario()
ts.set_ruleset(
"management_board_config",
[
{
"condition": {},
"options": {},
"value": (protocol, ruleset_credentials),
},
],
)
ts.add_host("mgmt-host", host_path="/wato/folder1/hosts.mk")
ts.set_option("ipaddresses", {"mgmt-host": "127.0.0.1"})
ts.set_option("management_protocol", {"mgmt-host": protocol})
ts.set_option(cred_attribute, {"mgmt-host": host_credentials})
config_cache = ts.apply(monkeypatch)
host_config = config_cache.get_host_config("mgmt-host")
assert host_config.has_management_board
assert host_config.management_protocol == protocol
assert host_config.management_address == "127.0.0.1"
assert host_config.management_credentials == host_credentials
def test_get_cmk_passive_service_attributes(monkeypatch, hostname, result):
ts = Scenario().add_host("localhost")
ts.add_host("blub")
ts.set_option(
"extra_service_conf",
{
"contact_groups": [
("ding", ["localhost"], ["CPU load$"]),
],
"check_interval": [
(40.0, ["blub"], ["Check_MK$"]),
(33.0, ["localhost"], ["CPU load$"]),
],
},
)
config_cache = ts.apply(monkeypatch)
host_config = config_cache.get_host_config(hostname)
check_mk_attrs = core_config.get_service_attributes(
hostname, "Check_MK", config_cache)
service = Service(CheckPluginName("cpu_loads"), None, "CPU load", {})
service_spec = core_config.get_cmk_passive_service_attributes(
config_cache, host_config, service, check_mk_attrs)
assert service_spec == result
def test_mgmt_disabled(monkeypatch):
ts = Scenario()
ts.add_host("mgmt-host")
ts.set_option("ipaddresses", {"mgmt-host": "127.0.0.1"})
ts.set_option("management_protocol", {"mgmt-host": None})
ts.set_option("host_attributes",
{"mgmt-host": {
"management_address": "127.0.0.1"
}})
ts.set_option("management_snmp_credentials", {"mgmt-host": "HOST"})
config_cache = ts.apply(monkeypatch)
host_config = config_cache.get_host_config("mgmt-host")
assert host_config.has_management_board is False
assert host_config.management_protocol is None
assert host_config.management_address == "127.0.0.1"
assert host_config.management_credentials is None
def test_get_labels_of_host(monkeypatch):
automation = automations.AutomationGetLabelsOf()
ts = Scenario().add_host("test-host")
ts.set_option(
"host_labels",
{
"test-host": {
"explicit": "ding",
},
},
)
ts.apply(monkeypatch)
assert automation.execute(["host", "test-host"]) == GetLabelsOfResult({
"label_sources": {
"cmk/site": "discovered",
"explicit": "explicit"
},
"labels": {
"cmk/site": "NO_SITE",
"explicit": "ding"
},
})
def test_create_nagios_host_spec(hostname_str: str, result: Dict[str, str],
monkeypatch: MonkeyPatch) -> None:
if cmk_version.is_managed_edition():
result = result.copy()
result["_CUSTOMER"] = "provider"
ts = Scenario()
ts.add_host(HostName("localhost"))
ts.add_host(HostName("host2"))
ts.add_cluster(HostName("cluster1"))
ts.add_cluster(HostName("cluster2"), nodes=["node1", "node2"])
ts.add_host(HostName("node1"))
ts.add_host(HostName("node2"))
ts.add_host(HostName("switch"))
ts.set_option(
"ipaddresses",
{
HostName("node1"): "127.0.0.1",
HostName("node2"): "127.0.0.2",
},
)
ts.set_option(
"extra_host_conf",
{
"alias": [
("lOCALhost", ["localhost"]),
],
},
)
ts.set_option(
"extra_host_conf",
{
"alias": [
("lOCALhost", ["host2"]),
("CLUSTer", ["cluster2"]),
],
"parents": [
("switch", ["node1", "node2"]),
],
},
)
hostname = HostName(hostname_str)
outfile = io.StringIO()
cfg = core_nagios.NagiosConfig(outfile, [hostname])
config_cache = ts.apply(monkeypatch)
host_attrs = core_config.get_host_attributes(hostname, config_cache)
host_spec = core_nagios._create_nagios_host_spec(cfg, config_cache,
hostname, host_attrs)
assert host_spec == result
def test_mgmt_explicit_settings(monkeypatch, protocol, cred_attribute,
credentials):
ts = Scenario()
ts.add_host("mgmt-host")
ts.set_option("ipaddresses", {"mgmt-host": "127.0.0.1"})
ts.set_option("management_protocol", {"mgmt-host": protocol})
ts.set_option(cred_attribute, {"mgmt-host": credentials})
config_cache = ts.apply(monkeypatch)
host_config = config_cache.get_host_config("mgmt-host")
assert host_config.has_management_board
assert host_config.management_protocol == protocol
assert host_config.management_address == "127.0.0.1"
assert host_config.management_credentials == credentials
def test_mgmt_explicit_address(monkeypatch):
ts = Scenario()
ts.add_host("mgmt-host")
ts.set_option("ipaddresses", {"mgmt-host": "127.0.0.1"})
ts.set_option("management_protocol", {"mgmt-host": "snmp"})
ts.set_option("host_attributes",
{"mgmt-host": {
"management_address": "127.0.0.2"
}})
config_cache = ts.apply(monkeypatch)
host_config = config_cache.get_host_config("mgmt-host")
assert host_config.has_management_board
assert host_config.management_protocol == "snmp"
assert host_config.management_address == "127.0.0.2"
assert host_config.management_credentials == "public"
def scenario_fixture(monkeypatch):
test_hosts = ["ds-test-host1", "ds-test-host2", "ds-test-node1", "ds-test-node2"]
ts = Scenario()
if is_enterprise_repo():
ts.set_option("monitoring_core", "cmc")
else:
ts.set_option("monitoring_core", "nagios")
for h in test_hosts:
ts.add_host(h)
ts.set_option("ipaddresses", dict((h, "127.0.0.1") for h in test_hosts))
ts.add_cluster("ds-test-cluster1", nodes=["ds-test-node1", "ds-test-node2"])
ts.fake_standard_linux_agent_output(*test_hosts)
return ts.apply(monkeypatch)
def scenario(self, hostname, ipaddress, monkeypatch):
ts = Scenario()
ts.add_host(hostname)
ts.set_option("ipaddresses", {hostname: ipaddress})
ts.apply(monkeypatch)
return ts
def test_check_table__get_static_check_entries(
monkeypatch: MonkeyPatch, check_group_parameters: LegacyCheckParameters
) -> None:
hostname = HostName("hostname")
static_parameters = {
"levels": (1, 2, 3, 4),
}
static_checks: Dict[str, List] = {
"ps": [(("ps", "item", static_parameters), [], [hostname], {})],
}
ts = Scenario().add_host(hostname)
ts.set_option("static_checks", static_checks)
ts.set_ruleset(
"checkgroup_parameters",
{
"ps": [(check_group_parameters, [hostname], [], {})],
},
)
config_cache = ts.apply(monkeypatch)
monkeypatch.setattr(
agent_based_register,
"get_check_plugin",
lambda cpn: CheckPlugin(
CheckPluginName("ps"),
[],
"Process item",
None, # type: ignore
None, # type: ignore
None, # type: ignore
None, # type: ignore
None, # type: ignore
{},
"ps", # type: ignore
None, # type: ignore
None, # type: ignore
),
)
host_config = config_cache.get_host_config(hostname)
static_check_parameters = [
service.parameters
for service in check_table._get_static_check_entries(config_cache, host_config)
]
entries = config._get_checkgroup_parameters(
config_cache,
hostname,
"ps",
"item",
"Process item",
)
assert len(entries) == 1
assert entries[0] == check_group_parameters
assert len(static_check_parameters) == 1
static_check_parameter = static_check_parameters[0]
assert static_check_parameter == static_parameters
def test_get_check_table_of_static_check(
monkeypatch: MonkeyPatch, hostname_str: str, expected_result: List[ServiceID]
) -> None:
hostname = HostName(hostname_str)
static_checks = {
"df_host": [
Service(
CheckPluginName("df"),
"/snap/core/9066",
"Filesystem /snap/core/9066",
[
{"tp_values": [("24X7", {"inodes_levels": None})], "tp_default_value": {}},
{
"trend_range": 24,
"show_levels": "onmagic",
"inodes_levels": (10.0, 5.0),
"magic_normsize": 20,
"show_inodes": "onlow",
"levels": (80.0, 90.0),
"show_reserved": False,
"levels_low": (50.0, 60.0),
"trend_perfdata": True,
},
],
),
],
"df_host_1": [
Service(
CheckPluginName("df"),
"/snap/core/9067",
"Filesystem /snap/core/9067",
{
"trend_range": 24,
"show_levels": "onmagic",
"inodes_levels": (10.0, 5.0),
"magic_normsize": 20,
"show_inodes": "onlow",
"levels": (80.0, 90.0),
"tp_default_value": {"levels": (87.0, 90.0)},
"show_reserved": False,
"tp_values": [("24X7", {"inodes_levels": None})],
"levels_low": (50.0, 60.0),
"trend_perfdata": True,
},
)
],
"df_host_2": [
Service(CheckPluginName("df"), "/snap/core/9068", "Filesystem /snap/core/9068", None)
],
}
ts = Scenario().add_host(hostname, tags={"criticality": "test"})
ts.add_host("df_host")
ts.add_host("df_host_1")
ts.add_host("df_host_2")
ts.set_option(
"static_checks",
{
"filesystem": [
(
(
"df",
"/snap/core/9066",
[
{
"tp_values": [("24X7", {"inodes_levels": None})],
"tp_default_value": {},
},
{
"trend_range": 24,
"show_levels": "onmagic",
"inodes_levels": (10.0, 5.0),
"magic_normsize": 20,
"show_inodes": "onlow",
"levels": (80.0, 90.0),
"show_reserved": False,
"levels_low": (50.0, 60.0),
"trend_perfdata": True,
},
],
),
[],
["df_host"],
),
(
(
"df",
"/snap/core/9067",
[
{
"tp_values": [("24X7", {"inodes_levels": None})],
"tp_default_value": {},
},
{
"trend_range": 24,
"show_levels": "onmagic",
"inodes_levels": (10.0, 5.0),
"magic_normsize": 20,
"show_inodes": "onlow",
"levels": (80.0, 90.0),
"show_reserved": False,
"levels_low": (50.0, 60.0),
"trend_perfdata": True,
},
],
),
[],
["df_host_1"],
),
(("df", "/snap/core/9068", None), [], ["df_host_2"]),
],
},
)
config_cache = ts.apply(monkeypatch)
monkeypatch.setattr(config_cache, "get_autochecks_of", lambda h: static_checks.get(h, []))
assert list(check_table.get_check_table(hostname).keys()) == expected_result
def test_get_check_table(
monkeypatch: MonkeyPatch, hostname_str: str, expected_result: HostCheckTable
) -> None:
hostname = HostName(hostname_str)
autochecks = {
"ping-host": [
Service(
CheckPluginName("smart_temp"),
"bla",
"Temperature SMART bla",
{},
)
],
"autocheck-overwrite": [
Service(
CheckPluginName("smart_temp"),
"/dev/sda",
"Temperature SMART /dev/sda",
{"is_autocheck": True},
),
Service(
CheckPluginName("smart_temp"),
"/dev/sdb",
"Temperature SMART /dev/sdb",
{"is_autocheck": True},
),
],
"ignore-not-existing-checks": [
Service(
CheckPluginName("bla_blub"),
"ITEM",
"Blub ITEM",
{},
),
],
"node1": [
Service(
CheckPluginName("smart_temp"),
"auto-clustered",
"Temperature SMART auto-clustered",
{},
),
Service(
CheckPluginName("smart_temp"),
"auto-not-clustered",
"Temperature SMART auto-not-clustered",
{},
),
],
}
ts = Scenario().add_host(hostname, tags={"criticality": "test"})
ts.add_host("ping-host", tags={"agent": "no-agent"})
ts.add_host("node1")
ts.add_cluster("cluster1", nodes=["node1"])
ts.set_option(
"static_checks",
{
"temperature": [
(("smart.temp", "/dev/sda", {}), [], ["no-autochecks", "autocheck-overwrite"]),
(("blub.bla", "ITEM", {}), [], ["ignore-not-existing-checks"]),
(("smart.temp", "ITEM1", {}), [], ["ignore-disabled-rules"], {"disabled": True}),
(("smart.temp", "ITEM2", {}), [], ["ignore-disabled-rules"]),
(("smart.temp", "/dev/sda", {"rule": 1}), [], ["static-check-overwrite"]),
(("smart.temp", "/dev/sda", {"rule": 2}), [], ["static-check-overwrite"]),
(("smart.temp", "static-node1", {}), [], ["node1"]),
(("smart.temp", "static-cluster", {}), [], ["cluster1"]),
]
},
)
ts.set_ruleset(
"clustered_services",
[
([], ["node1"], ["Temperature SMART auto-clustered$"]),
],
)
config_cache = ts.apply(monkeypatch)
monkeypatch.setattr(config_cache, "get_autochecks_of", lambda h: autochecks.get(h, []))
assert check_table.get_check_table(hostname) == expected_result
def test_get_check_table(monkeypatch: MonkeyPatch, hostname_str: str,
expected_result: HostCheckTable) -> None:
hostname = HostName(hostname_str)
ts = Scenario()
ts.add_host(hostname, tags={"criticality": "test"})
ts.add_host("ping-host", tags={"agent": "no-agent"})
ts.add_host("node1")
ts.add_cluster("cluster1", nodes=["node1"])
ts.set_option(
"static_checks",
{
"temperature": [
(("smart.temp", "/dev/sda", {}), [],
["no-autochecks", "autocheck-overwrite"]),
(("blub.bla", "ITEM", {}), [], ["ignore-not-existing-checks"]),
(("smart.temp", "ITEM1", {}), [], ["ignore-disabled-rules"], {
"disabled": True
}),
(("smart.temp", "ITEM2", {}), [], ["ignore-disabled-rules"]),
(("smart.temp", "/dev/sda", {
"rule": 1
}), [], ["static-check-overwrite"]),
(("smart.temp", "/dev/sda", {
"rule": 2
}), [], ["static-check-overwrite"]),
(("smart.temp", "static-node1", {}), [], ["node1"]),
(("smart.temp", "static-cluster", {}), [], ["cluster1"]),
]
},
)
ts.set_ruleset(
"clustered_services",
[
([], ["node1"], ["Temperature SMART auto-clustered$"]),
],
)
ts.set_autochecks(
"ping-host",
[
AutocheckEntry(CheckPluginName("smart_temp"), "bla", {}, {}),
],
)
ts.set_autochecks(
"autocheck-overwrite",
[
AutocheckEntry(CheckPluginName("smart_temp"), "/dev/sda",
{"is_autocheck": True}, {}),
AutocheckEntry(CheckPluginName("smart_temp"), "/dev/sdb",
{"is_autocheck": True}, {}),
],
)
ts.set_autochecks(
"ignore-not-existing-checks",
[
AutocheckEntry(CheckPluginName("bla_blub"), "ITEM", {}, {}),
],
)
ts.set_autochecks(
"node1",
[
AutocheckEntry(CheckPluginName("smart_temp"), "auto-clustered", {},
{}),
AutocheckEntry(CheckPluginName("smart_temp"), "auto-not-clustered",
{}, {}),
],
)
ts.apply(monkeypatch)
assert set(check_table.get_check_table(hostname)) == set(expected_result)
for key, value in check_table.get_check_table(hostname).items():
assert key in expected_result
assert expected_result[key] == value
def fixture_core_scenario(monkeypatch):
ts = Scenario().add_host("test-host")
ts.set_option("ipaddresses", {"test-host": "127.0.0.1"})
return ts.apply(monkeypatch)
