Files
napalm-openmediavault/tests/test_disks.py
T
Christian Manivong 6b9ba25773
driver / standard (pull_request) Successful in 14s
driver / lint (pull_request) Successful in 13s
driver / types (pull_request) Successful in 1m6s
driver / test (3.12) (pull_request) Successful in 1m2s
driver / test (3.13) (pull_request) Successful in 56s
driver / lowest (pull_request) Successful in 28s
driver / build (pull_request) Successful in 28s
driver / security (pull_request) Successful in 1m5s
CI / driver (pull_request) Successful in 2m34s
driver / publish (pull_request) Skipped
fix(disks): read the SMART verdict and md membership correctly
get_disks ran smartctl -iA, and neither -i nor -A prints the overall
verdict: only -H does. A disk read unknown, and an ATA disk read failed
from the WHEN_FAILED column header of its attribute table. It now asks
-iHA and reads the verdict line (ATA/NVMe) or SCSI health status only.

Array membership matched the disk name as a substring of the mdstat
line, so sda joined the array of sdaa1. A disk now owns only itself and
its partitions, and /proc/mdstat is read once per call.

Closes #4
2026-11-01 21:47:49 +01:00

233 lines
7.8 KiB
Python

"""get_disks: the overall SMART verdict, and the md array each disk belongs to.
smartctl prints the overall verdict only for ``-H``; ``-i`` (identity) and ``-A``
(attributes) never do. The fake host below answers smartctl the way it builds its
output: one section per flag asked for, so a command without ``-H`` gets no verdict.
The sections are in the form smartmontools 7.3 prints them (ATA, NVMe and SCSI),
cut to the lines that matter here; they are not recorded from a device.
"""
from __future__ import annotations
import json
import re
import pytest
from napalm_openmediavault.openmediavault import OpenMediaVaultDriver, smart_health
_BANNER = (
"smartctl 7.3 2022-02-28 r5338 [x86_64-linux-6.1.0-26-amd64] (local build)\n"
"Copyright (C) 2002-22, Bruce Allen, Christian Franke, www.smartmontools.org\n"
)
ATA_INFO = """\
=== START OF INFORMATION SECTION ===
Model Family: HGST Ultrastar 7K6
Device Model: HGST HUS726T6TALE6L4
Serial Number: K1AAAAAA
Rotation Rate: 7200 rpm
SMART support is: Available - device has SMART capability.
SMART support is: Enabled
"""
ATA_PASSED = "SMART overall-health self-assessment test result: PASSED\n"
ATA_FAILED = (
"SMART overall-health self-assessment test result: FAILED!\n"
"Drive failure expected in less than 24 hours. SAVE ALL DATA.\n"
)
ATA_ATTRIBUTES = """\
SMART Attributes Data Structure revision number: 16
Vendor Specific SMART Attributes with Thresholds:
ID# ATTRIBUTE_NAME FLAG VALUE WORST THRESH TYPE UPDATED WHEN_FAILED RAW_VALUE
1 Raw_Read_Error_Rate 0x000b 100 100 016 Pre-fail Always - 0
194 Temperature_Celsius 0x0002 176 176 000 Old_age Always - 34 (Min/Max 20/45)
"""
NVME_INFO = """\
=== START OF INFORMATION SECTION ===
Model Number: Samsung SSD 980 PRO 1TB
Serial Number: S5AAAAAAAAAAAAA
"""
NVME_PASSED = "SMART overall-health self-assessment test result: PASSED\n"
NVME_ATTRIBUTES = """\
SMART/Health Information (NVMe Log 0x02)
Critical Warning: 0x00
Temperature: 41 Celsius
"""
SCSI_OK = "SMART Health Status: OK\n"
SCSI_PREDICTED = (
"SMART Health Status: FIRMWARE IMPENDING FAILURE TOO MANY BLOCK REASSIGNS [asc=5d, ascq=64]\n"
)
USB_NO_SMART = (
"SMART support is: Unavailable - device lacks SMART capability.\n"
"\n"
"A mandatory SMART command failed: exiting. To continue, add one or more '-T permissive' options.\n"
)
def smartctl(flags: str, info: str, health: str, attributes: str) -> str:
"""What ``smartctl -<flags>`` prints: the banner, then one section per flag."""
out = _BANNER + "\n"
if "i" in flags:
out += info + "\n"
if "H" in flags or "A" in flags:
out += "=== START OF READ SMART DATA SECTION ===\n"
if "H" in flags:
out += health + "\n"
if "A" in flags:
out += attributes
return out
class Nas:
"""The NAS as ``_send`` and ``_sudo`` see it: lsblk, /proc/mdstat and smartctl."""
def __init__(self, disks: dict[str, tuple[str, str, str, str]], mdstat: str = "") -> None:
#: name -> (tran, info, health, attributes)
self.disks = disks
self.mdstat = mdstat
self.commands: list[str] = []
def send(self, command: str, read_timeout: float = 100) -> str:
self.commands.append(command)
if command.startswith("lsblk "):
return json.dumps(
{
"blockdevices": [
{
"name": name,
"size": 6001175126016,
"type": "disk",
"rota": tran != "nvme",
"vendor": "",
"model": "m",
"serial": "s",
"tran": tran,
}
for name, (tran, *_rest) in self.disks.items()
]
}
)
if command.startswith("cat /proc/mdstat"):
return self.mdstat
raise AssertionError(command)
def sudo(self, command: str, read_timeout: float = 100) -> str:
self.commands.append(command)
m = re.match(r"smartctl -(\w+) /dev/(\w+)", command)
assert m, command
_tran, info, health, attributes = self.disks[m.group(2)]
return smartctl(m.group(1), info, health, attributes)
def _driver(nas: Nas) -> OpenMediaVaultDriver:
driver = OpenMediaVaultDriver("nas", "admin", "p")
driver._send = nas.send # type: ignore[method-assign]
driver._sudo = nas.sudo # type: ignore[method-assign]
return driver
def _by_slot(nas: Nas) -> dict[str, dict]:
return {d["slot"]: dict(d) for d in _driver(nas).get_disks()}
# ── the overall verdict ─────────────────────────────────────────────────────────
def test_a_passing_ata_disk_is_healthy():
nas = Nas({"sda": ("sata", ATA_INFO, ATA_PASSED, ATA_ATTRIBUTES)})
disk = _by_slot(nas)["/dev/sda"]
assert disk["health"] == "healthy"
assert (disk["temperature"], disk["rpm"]) == (34, 7200)
def test_a_failing_ata_disk_is_failed():
nas = Nas({"sda": ("sata", ATA_INFO, ATA_FAILED, ATA_ATTRIBUTES)})
assert _by_slot(nas)["/dev/sda"]["health"] == "failed"
def test_a_passing_nvme_disk_is_healthy():
nas = Nas({"nvme0n1": ("nvme", NVME_INFO, NVME_PASSED, NVME_ATTRIBUTES)})
disk = _by_slot(nas)["/dev/nvme0n1"]
assert (disk["health"], disk["temperature"]) == ("healthy", 41)
@pytest.mark.parametrize(
("output", "health"),
[
(ATA_PASSED, "healthy"),
(ATA_FAILED, "failed"),
(NVME_PASSED, "healthy"),
(SCSI_OK, "healthy"),
(SCSI_PREDICTED, "failed"),
(USB_NO_SMART, "unknown"),
("", "unknown"),
# The attribute table's WHEN_FAILED column is no verdict.
(ATA_ATTRIBUTES, "unknown"),
],
ids=[
"ata-passed",
"ata-failed",
"nvme-passed",
"scsi-ok",
"scsi-predicted",
"no-smart",
"empty",
"when-failed-column",
],
)
def test_smart_health_reads_the_verdict_line_only(output, health):
assert smart_health(_BANNER + output) == health
# ── md membership ───────────────────────────────────────────────────────────────
MDSTAT = """\
Personalities : [raid1] [linear] [multipath] [raid0] [raid6] [raid5] [raid4] [raid10]
md0 : active raid1 sdab1[1] sdaa1[0]
976630464 blocks super 1.2 [2/2] [UU]
md1 : active raid1 sdb1[1] sdc1[0](F)
5860389888 blocks super 1.2 [2/1] [U_]
md2 : active raid1 nvme0n1p1[0] nvme1n1[1]
976630464 blocks super 1.2 [2/2] [UU]
md3 : active raid1 nvme2n11[0] nvme2n12[1]
976630464 blocks super 1.2 [2/2] [UU]
unused devices: <none>
"""
def test_a_disk_is_in_the_array_its_partition_or_itself_is_in():
names = ["sda", "sdaa", "sdc", "nvme0n1", "nvme1n1", "nvme2n1"]
nas = Nas({n: ("sata", ATA_INFO, ATA_PASSED, ATA_ATTRIBUTES) for n in names}, MDSTAT)
pools = {slot: d["pool"] for slot, d in _by_slot(nas).items()}
assert pools == {
"/dev/sda": "", # sdaa1 and sdab1 are not sda's
"/dev/sdaa": "md0",
"/dev/sdc": "md1", # a failed member is still a member
"/dev/nvme0n1": "md2",
"/dev/nvme1n1": "md2",
"/dev/nvme2n1": "", # nvme2n11 is another namespace, not a partition
}
def test_mdstat_is_read_once_for_all_disks():
nas = Nas({n: ("sata", ATA_INFO, ATA_PASSED, ATA_ATTRIBUTES) for n in ("sda", "sdb")}, MDSTAT)
_driver(nas).get_disks()
assert sum(c.startswith("cat /proc/mdstat") for c in nas.commands) == 1