def check_huawei_storage_hwcache(item, params, section) -> CheckResult:
for id, ru, wu, mwu, hr in section:
if item == id:
yield Result(state=State.OK, summary="HWCache %s: ok" % item)
yield Metric("read_utilization", int(ru))
yield Metric("write_utilization", int(wu))
yield Metric("mirror_write_utilization", int(mwu))
yield Metric("hit_ratio", int(hr))
def test_check_disk():
with pytest.raises(IgnoreResultsError):
list(aix_diskiod._check_disk({}, DISK))
assert list(aix_diskiod._check_disk({}, DISK)) == [
Result(state=state.OK, summary="Read: 0.00 B/s"),
Metric("disk_read_throughput", 0.0),
Result(state=state.OK, summary="Write: 0.00 B/s"),
Metric("disk_write_throughput", 0.0),
]
def test_check_disk(value_store):
with pytest.raises(IgnoreResultsError):
list(aix_diskiod._check_disk({}, DISK))
assert list(aix_diskiod._check_disk({}, DISK)) == [
Result(state=state.OK, summary='Read: 0.00 B/s'),
Metric('disk_read_throughput', 0.0),
Result(state=state.OK, summary='Write: 0.00 B/s'),
Metric('disk_write_throughput', 0.0),
]
def test_check() -> None:
section = parse_ruckus_spot_ap(STRING_TABLE)
params = {"levels_drifted": (0, 1), "levels_not_responding": (2, 3)}
assert [*check_ruckus_spot_ap("5 GHz", params, section)] == [
Result(state=State.OK, summary="Devices: 2"),
Metric("ap_devices_total", 2.0),
Result(state=State.WARN, summary="Drifted: 0 (warn/crit at 0/1)"),
Metric("ap_devices_drifted", 0.0, levels=(0.0, 1.0)),
Result(state=State.OK, notice="Not responding: 1"),
Metric("ap_devices_not_responding", 1.0, levels=(2.0, 3.0)),
]
def test_check_fast_lta_volumes(check_fast_lta_volumes) -> None:
assert list(check_fast_lta_volumes("Archiv_Test", {}, parsed)) == [
Result(state=State.OK, summary="1.0% used (9.31 of 931.32 GB)"),
Metric(
"fs_used",
9536.7431640625,
levels=(762939.453125, 858306.884765625),
boundaries=(0.0, 953674.31640625),
),
Metric("fs_size", 953674.31640625),
Metric("fs_used_percent", 1.0),
]
def test_check_k8s_node_count_default_params() -> None:
result = list(
check(check_default_parameters, NodeCount(worker=0, control_plane=0)))
assert result == [
Result(state=State.CRIT,
summary="Number of worker nodes: 0 (warn/crit below 3/1)"),
Metric("k8s_node_count_worker", 0.0, boundaries=(0.0, None)),
Result(
state=State.CRIT,
summary="Number of control plane nodes: 0 (warn/crit below 3/1)"),
Metric("k8s_node_count_control_plane", 0.0, boundaries=(0.0, None)),
]
def test_check_fast_lta_silent_cube_capacity(
check_fast_lta_silent_cubes_capacity) -> None:
assert list(check_fast_lta_silent_cubes_capacity(None, {}, info)) == [
Result(state=State.OK, summary="48.43% used (3.52 of 7.28 TB)"),
Metric("fs_used",
3695972.90234375,
levels=(6104729.6, 6867820.8),
boundaries=(0.0, 7630912.0)),
Metric("fs_size", 7630912.0),
Metric("fs_used_percent", 48.4342225718728),
]
def test_check_ps_common_cpu(data):
def time_info(service, agent_info, check_time, cputime, cpu_cores):
with on_time(datetime.datetime.utcfromtimestamp(check_time), "CET"):
_cpu_info, parsed_lines = ps_section.parse_ps(
splitter(agent_info.format(cputime)))
lines_with_node_name: List[Tuple[Optional[str], ps_utils.PsInfo,
List[str]]] = [
(None, ps_info, cmd_line)
for (ps_info,
cmd_line) in parsed_lines
]
return list(
ps_utils.check_ps_common(
label="Processes",
item=service.item,
params=service.parameters, # type: ignore[arg-type]
process_lines=lines_with_node_name,
cpu_cores=cpu_cores,
total_ram_map={},
))
rescale_params = ({
"cpu_rescale_max": data.cpu_rescale_max
} if data.cpu_rescale_max is not None else {})
service = Service(
item="test",
parameters={
"process": "~test",
"user": None,
"levels": (1, 1, 99999, 99999), # from factory defaults
**rescale_params,
},
)
# Initialize counters
time_info(service, data.agent_info, 0, 0, data.cpu_cores)
# Check_cpu_utilization
output = time_info(service, data.agent_info, 60, data.cputime,
data.cpu_cores)
assert output[:6] == [
Result(state=state.OK, summary="Processes: 1"),
Metric("count", 1, levels=(100000, 100000), boundaries=(0, None)),
Result(state=state.OK, summary="virtual: 105 KiB"),
Metric("vsz", 105),
Result(state=state.OK, summary="physical: 30.0 KiB"),
Metric("rss", 30),
]
assert output[8:] == [
Result(state=state.OK, summary="Running for: 3 hours 59 minutes"),
]
def fixture_fetcher_checker_counters_list():
return [
Result(state=state.OK, notice="Fetcher helper usage: 0%"),
Metric("helper_usage_fetcher",
0.0,
levels=(80.0, 90.0),
boundaries=(0.0, None)),
Result(state=state.OK, notice="Checker helper usage: 0%"),
Metric("helper_usage_checker",
0.0,
levels=(80.0, 90.0),
boundaries=(0.0, None)),
]
def test_check_disk():
value_store: dict[str, Any] = {}
now = 1647029464.27418
with pytest.raises(IgnoreResultsError):
list(aix_diskiod._check_disk({}, DISK, value_store, now))
assert list(aix_diskiod._check_disk({}, DISK, value_store, now + 60)) == [
Result(state=state.OK, summary="Read: 0.00 B/s"),
Metric("disk_read_throughput", 0.0),
Result(state=state.OK, summary="Write: 0.00 B/s"),
Metric("disk_write_throughput", 0.0),
]
def test_docker_container_diskstat(
fix_register,
section_name: str,
plugin_name: str,
string_table_0,
string_table_10,
read_bytes,
write_bytes,
read_ops,
write_ops,
) -> None:
agent_section = fix_register.agent_sections[SectionName(section_name)]
plugin = fix_register.check_plugins[CheckPluginName(plugin_name)]
section_0_seconds = agent_section.parse_function(string_table_0)
section_60_seconds = agent_section.parse_function(string_table_10)
with pytest.raises(IgnoreResultsError):
# first run, no rate metrics yet:
_ = list(
plugin.check_function(
params={},
section_multipath=None,
section_diskstat=section_0_seconds,
item="SUMMARY",
))
# now we have a rate:
result = list(
plugin.check_function(
params={},
section_multipath=None,
section_diskstat=section_60_seconds,
item="SUMMARY",
))
expected_result = [
Result(state=State.OK, summary=f"Read: {iobandwidth(read_bytes)}"),
Metric("disk_read_throughput", read_bytes),
Result(state=State.OK, summary=f"Write: {iobandwidth(write_bytes)}"),
Metric("disk_write_throughput", write_bytes),
]
if write_ops != 0 and read_ops != 0:
expected_result += [
Result(state=State.OK,
notice=f"Read operations: {read_ops:.2f}/s"),
Metric("disk_read_ios", read_ops),
Result(state=State.OK,
notice=f"Write operations: {write_ops:.2f}/s"),
Metric("disk_write_ios", write_ops),
]
assert result == expected_result
def check_proxmox_ve_disk_usage(params: Mapping[str, Any],
section: Section) -> CheckResult:
"""
>>> for result in check_proxmox_ve_disk_usage(
... {"levels": (80., 90.)},
... parse_proxmox_ve_disk_usage([['{"disk": 1073741824, "max_disk": 2147483648}']])):
... print(result)
Metric('fs_used', 1073741824.0, levels=(1717986918.4, 1932735283.2), boundaries=(0.0, 2147483648.0))
Metric('fs_size', 2147483648.0, boundaries=(0.0, None))
Metric('fs_used_percent', 50.0, levels=(80.0, 90.0), boundaries=(0.0, 100.0))
Result(state=<State.OK: 0>, summary='50.00% used (1.07 GB of 2.15 GB)')
"""
used_bytes, total_bytes = section.get("disk",
0), section.get("max_disk", 0)
warn, crit = params.get("levels", (0.0, 0.0))
warn_bytes, crit_bytes = (warn / 100 * total_bytes,
crit / 100 * total_bytes)
if total_bytes == 0:
yield Result(state=State.WARN, summary="Size of filesystem is 0 MB")
return
yield Metric(
"fs_used",
used_bytes,
levels=(warn_bytes, crit_bytes),
boundaries=(0, total_bytes),
)
yield Metric(
"fs_size",
total_bytes,
boundaries=(0, None),
)
yield Metric(
"fs_used_percent",
100.0 * used_bytes / total_bytes,
levels=(warn, crit),
boundaries=(0.0, 100.0),
)
yield Result(
state=(State.CRIT if used_bytes >= crit_bytes else
State.WARN if used_bytes >= warn_bytes else State.OK),
summary="%s used (%s of %s)" % (
render.percent(100.0 * used_bytes / total_bytes),
render.disksize(used_bytes),
render.disksize(total_bytes),
),
)
def test_check_netscaler_vservers_clustered_best(clustered_vservers):
assert list(
_check_netscaler_vservers(
Parameters({
"health_levels": (100.0, 0.1),
"cluster_status": "best",
}),
clustered_vservers,
)
) == [
Result(state=state.OK,
summary='Status: up (node1)',
details='Status: up (node1)'),
Result(state=state.OK,
summary='Status: busy (node2)',
details='Status: busy (node2)'),
Result(state=state.WARN,
summary='Health: 75.2% (warn/crit below 100%/0.10%)',
details='Health: 75.2% (warn/crit below 100%/0.10%)'),
Metric('health_perc',
75.2,
levels=(None, None),
boundaries=(0.0, 100.0)),
Result(
state=state.OK,
summary='Type: loadbalancing, Protocol: ssl, Socket: 0.0.0.0:0',
details='Type: loadbalancing, Protocol: ssl, Socket: 0.0.0.0:0'),
Result(state=state.OK,
summary='Request rate: 1/s',
details='Request rate: 1/s'),
Metric('request_rate',
1.0,
levels=(None, None),
boundaries=(None, None)),
Result(state=state.OK,
summary='In: 16.0 Bit/s',
details='In: 16.0 Bit/s'),
Metric('if_in_octets',
2.0,
levels=(None, None),
boundaries=(None, None)),
Result(state=state.OK,
summary='Out: 40.0 Bit/s',
details='Out: 40.0 Bit/s'),
Metric('if_out_octets',
5.0,
levels=(None, None),
boundaries=(None, None)),
]
def test_basic_cpu_loads():
section = parse_cpu(STRING_TABLE) # type: ignore[arg-type]
assert section
result = list(
check_cpu_load(
params={"levels": (5.0, 10.0)},
section=section,
))
assert result == [
Result(state=State.OK, summary="15 min load: 0.87"),
Metric("load15", 0.87, levels=(40.0, 80.0)),
Result(state=State.OK, summary="15 min load per core: 0.11 (8 cores)"),
Metric("load1", 0.88, boundaries=(0.0, 8.0)),
Metric("load5", 0.83, boundaries=(0.0, 8.0)),
]
def test_check_job3_item(section: jn.Section) -> None:
assert list(jn.check_jenkins_jobs("project/Job3", {}, section)) == [
jn.Result(state=jn.State.OK, summary="Display name: Job 3"),
jn.Result(state=jn.State.OK, summary="State: Success"),
jn.Result(state=jn.State.OK, summary="Job score: 100.00%"),
Metric("jenkins_job_score", 100.0),
jn.Result(state=jn.State.OK, summary="Time since last build: 7 days 1 hour"),
Metric("jenkins_last_build", 609957.0),
jn.Result(state=jn.State.OK, summary="Time since last successful build: 7 days 1 hour"),
Metric("jenkins_time_since", 609956.5680000782),
jn.Result(state=jn.State.OK, summary="Build id: 26"),
jn.Result(state=jn.State.OK, summary="Build duration: 3 minutes 14 seconds"),
Metric("jenkins_build_duration", 193.715),
jn.Result(state=jn.State.CRIT, summary="Build result: Failure"),
]
def test_check_sap_hana_backup_CRIT():
params = {"backup_age": (1 * 60 * 60, 2 * 60 * 60)}
yielded_results = list(
sap_hana_backup.check_sap_hana_backup(ITEM, params, SECTION))
assert yielded_results == [
Result(state=state.OK,
summary='Status: successful',
details='Status: successful'),
Result(state=state.OK,
summary='Last: 2019-01-01 00:00:00',
details='Last: 2019-01-01 00:00:00'),
Result(
state=state.CRIT,
summary=
'Age: 22 hours 54 minutes (warn/crit at 1 hour 0 minutes/2 hours 0 minutes)',
details=
'Age: 22 hours 54 minutes (warn/crit at 1 hour 0 minutes/2 hours 0 minutes)'
),
Metric('backup_age', 82457.0, levels=(3600.0, 7200.0)),
Result(state=state.OK,
summary='Message: <ok>',
details='Message: <ok>'),
]
def check_bluecat_dhcp_one_lease():
assert list(
bluecat_dhcp.check_bluecat_dhcp(
{
"oper_states": {
"warning": [],
"critical": [],
},
},
{
"oper_state": 1,
"leases": 1,
},
)) == [
Result(
state=state.OK,
summary="DHCP is running normally",
),
Result(
state=state.OK,
summary="1 lease per second",
),
Metric(
"leases",
1,
),
]
def check_bluecat_dhcp_crit():
assert list(
bluecat_dhcp.check_bluecat_dhcp(
{
"oper_states": {
"warning": [],
"critical": [5],
},
},
{
"oper_state": 5,
"leases": 10,
},
)) == [
Result(
state=state.CRIT,
summary="DHCP is fault",
),
Result(
state=state.OK,
summary="1 lease per second",
),
Metric(
"leases",
1,
),
]
def test_fix_state():
local_result = local.LocalResult(
cached=None,
item="NotGood",
state=State.CRIT,
apply_levels=False,
text="A critical check",
perfdata=[
local.Perfdata(
name="V",
value=120,
levels_upper=(50, 100),
levels_lower=None,
boundaries=(0, 1000),
)
],
)
assert list(
local.check_local(
"NotGood", {},
local.LocalSection(errors=[],
data={"NotGood": local_result}))) == [
Result(state=State.CRIT,
summary="A critical check"),
Result(state=State.OK, summary='V: 120.00'),
Metric("V", 120, boundaries=(0, 1000)),
]
def test_cluster_check_pulse_secure_users():
assert list(
pulse_secure_users.cluster_check_pulse_secure_users(
{},
{
'node1': {
'n_users': 20
},
'node2': {
'n_users': 30
}
},
)) == [
Result(
state=state.OK,
notice='[node1]: Pulse Secure users: 20',
),
Result(
state=state.OK,
notice='[node2]: Pulse Secure users: 30',
),
Result(
state=state.OK,
summary='Pulse Secure users across cluster: 50',
details='Pulse Secure users across cluster: 50',
),
Metric(
'current_users',
50.0,
levels=(None, None),
boundaries=(None, None),
),
]
def test_check_sansymphony_pool_status_running_cache_mode_readwrite() -> None:
section = {
"Disk_pool_1":
SansymphonyPool(
name="Disk_pool_1",
percent_allocated=57.0,
status="Running",
cache_mode="ReadWrite",
pool_type="Dynamic",
),
}
assert list(
check_sansymphony_pool(
item="Disk_pool_1",
params={"allocated_pools_percentage_upper": (80.0, 90.0)},
section=section,
)
) == [
Result(
state=State.OK,
summary=
"Dynamic pool Disk_pool_1 is Running, its cache is in ReadWrite mode",
),
Result(state=State.OK, summary="Pool allocation: 57.00%"),
Metric("pool_allocation",
57.0,
levels=(80.0, 90.0),
boundaries=(0.0, 100.0)),
]
def test_cluster_check_sap_hana_backup_CRIT():
params = {"backup_age": (1 * 60 * 60, 2 * 60 * 60)}
section = {"node0": SECTION, "node1": SECTION}
yielded_results = list(
sap_hana_backup.cluster_check_sap_hana_backup(ITEM, params, section))
assert yielded_results == [
Result(state=state.OK,
summary='Nodes: node0, node1',
details='Nodes: node0, node1'),
Result(state=state.OK,
summary='Status: successful',
details='Status: successful'),
Result(state=state.OK,
summary='Last: 2019-01-01 00:00:00',
details='Last: 2019-01-01 00:00:00'),
Result(
state=state.CRIT,
summary=
'Age: 22 hours 54 minutes (warn/crit at 1 hour 0 minutes/2 hours 0 minutes)',
details=
'Age: 22 hours 54 minutes (warn/crit at 1 hour 0 minutes/2 hours 0 minutes)'
),
Metric('backup_age',
82457.0,
levels=(3600.0, 7200.0),
boundaries=(None, None)),
Result(state=state.OK,
summary='Message: <ok>',
details='Message: <ok>'),
]
def test_check2() -> None:
assert list(
check_mssql_jobs(
"Wartung Stündlich",
{
"ignore_db_status": False,
"status_disabled_jobs": 0,
"status_missing_jobs": 2,
"run_duration": (1800, 2400),
},
parse_mssql_jobs(INFO2),
)
) == [
Result(state=State.OK, summary="Last duration: 9 seconds"),
Metric("database_job_duration", 9.0, levels=(1800.0, 2400.0)),
Result(state=State.CRIT, summary="MSSQL status: Fail"),
Result(state=State.OK, summary="Last run: 2020-09-28 15:15:00"),
Result(state=State.OK, summary="Next run: 2020-09-28 16:15:00"),
Result(
state=State.OK,
notice=
("Outcome message: The job failed. JobManager tried to run a non-existent"
" step (3) for job Wartung Stündlich."),
),
]
def check_kube_pod_resources(
params: Params,
section_kube_pod_resources: Optional[PodResources],
section_kube_allocatable_pods: Optional[AllocatablePods],
) -> CheckResult:
assert section_kube_pod_resources is not None, "Missing Api data"
yield from check_kube_pods(params, section_kube_pod_resources)
if section_kube_allocatable_pods is None:
return
yield Result(
state=State.OK,
summary=_summary("allocatable",
section_kube_allocatable_pods.allocatable),
)
yield Result(
state=State.OK,
notice=_summary("capacity", section_kube_allocatable_pods.capacity),
)
if section_kube_allocatable_pods.kubernetes_object == "cluster":
param = params["free_cluster"]
elif section_kube_allocatable_pods.kubernetes_object == "node":
param = params["free_node"]
else:
raise AssertionError("Unknown Kubernetes object with capacity.")
yield from check_free_pods(
param,
section_kube_pod_resources,
section_kube_allocatable_pods.allocatable,
)
yield Metric(name="kube_pod_allocatable",
value=section_kube_allocatable_pods.allocatable)
def test_uptime_check_zero():
with on_time("2018-04-15 16:50", "CET"):
assert list(uptime_utils.check({}, uptime_utils.Section(0, None))) == [
Result(state=State.OK, summary="Up since Apr 15 2018 18:50:00"),
Result(state=State.OK, summary="Uptime: 0 seconds"),
Metric("uptime", 0.0),
]
def check_bluecat_dhcp_crit():
assert list(
bluecat_dhcp.check_bluecat_dhcp(
type_defs.Parameters(
{
"oper_states": {
"warning": [],
"critical": [5],
},
}, ),
{
'oper_state': 5,
'leases': 10,
},
)) == [
Result(
state=state.CRIT,
summary="DHCP is fault",
),
Result(
state=state.OK,
summary="1 lease per second",
),
Metric(
'leases',
1,
),
]
def test_fix_state():
local_result = local.LocalResult(
cached=None,
item="NotGood",
state=2,
text="A critical check",
perfdata=[
local.Perfdata(
name="V",
value=120,
levels=(50, 100, None, None),
tuple=("V", 120, 50, 100, 0, 1000),
)
],
)
assert list(local.check_local("NotGood", {},
{"NotGood": local_result})) == [
Result(state=state.CRIT,
summary="A critical check"),
Metric("V",
120,
levels=(50, 100),
boundaries=(0, 1000)),
]
def test_check3() -> None:
assert list(
check_mssql_jobs(
"aller 2h",
{
"ignore_db_status": True,
"status_disabled_jobs": 0,
"status_missing_jobs": 2,
"run_duration": (1800, 2400),
},
parse_mssql_jobs(INFO2),
)
) == [
Result(state=State.OK, summary="Last duration: 12 minutes 45 seconds"),
Metric("database_job_duration", 765.0, levels=(1800.0, 2400.0)),
Result(state=State.OK, summary="MSSQL status: Succeed"),
Result(state=State.OK, summary="Last run: 2020-09-28 15:05:01"),
Result(state=State.OK, summary="Next run: 2020-09-28 17:05:00"),
Result(
state=State.OK,
notice=
("Outcome message: The job succeeded. The Job was invoked by Schedule 48 (Mo-"
"Sa 07:00 aller 2h). The last step to run was step 2 (Magicinfo_Device_IP)."
),
),
]
def check_bluecat_dhcp_ok():
assert list(
bluecat_dhcp.check_bluecat_dhcp(
{
"oper_states": {
"warning": [],
"critical": [],
},
},
{
'oper_state': 1,
'leases': 11,
},
)) == [
Result(
state=state.OK,
summary="DHCP is running normally",
),
Result(
state=state.OK,
summary="11 leases per second",
),
Metric(
'leases',
11,
),
]
def test_check_kube_node_count_default_params_cp_zero() -> None:
result = list(
check(
check_default_parameters,
NodeCount(
worker=ReadyCount(ready=10, not_ready=2),
control_plane=ReadyCount(ready=0, not_ready=0),
),
))
assert result == [
Result(state=State.OK, summary="Worker nodes 10/12"),
Metric("kube_node_count_worker_ready", 10.0, boundaries=(0.0, None)),
Metric("kube_node_count_worker_not_ready", 2.0),
Metric("kube_node_count_worker_total", 12.0),
Result(state=State.OK, summary="No control plane nodes found"),
]
