Files
napalm-openmediavault/napalm_openmediavault/openmediavault.py
T
Christian Manivong e09af917c8
driver / standard (pull_request) Successful in 16s
driver / lint (pull_request) Successful in 13s
driver / types (pull_request) Successful in 1m2s
driver / test (3.12) (pull_request) Successful in 1m1s
driver / test (3.13) (pull_request) Successful in 58s
driver / lowest (pull_request) Successful in 28s
driver / build (pull_request) Successful in 27s
driver / security (pull_request) Successful in 1m5s
CI / driver (pull_request) Successful in 2m35s
driver / publish (pull_request) Skipped
fix(disks): read a SAS disk's temperature
A SCSI/SAS disk prints its temperature as "Current Drive Temperature:
28 C", which matched none of the ATA and NVMe patterns, so every SAS
disk read -1. Found in the smartctl output recorded from a Proxmox host.
A QEMU disk without a sensor prints 0 C there and keeps reading -1.
2026-11-01 22:15:35 +01:00

734 lines
29 KiB
Python

# Licensed under the Apache License, Version 2.0
"""NAPALM driver for OpenMediaVault NAS systems.
Extends LinuxDriver with OMV-specific storage management:
* Physical disk inventory via lsblk and smartctl
* md RAID array status via /proc/mdstat and mdadm
* Mounted filesystem info via df
* SMB, NFS, and FTP share enumeration via omv-confdbadm
Connects via SSH. Sudo access is required for smartctl and mdadm.
All optional_args from LinuxDriver are accepted (pkg_manager, sudo_password, …).
Tested against OpenMediaVault 6.x and 7.x (Debian Bullseye / Bookworm base).
"""
from __future__ import annotations
import json as _json
import logging
import re
from shlex import quote as _shlex_quote
from typing import Any
from napalm_device_types import FingerprintRule, StorageDriver
from napalm_device_types.models import (
DiskPoolDict,
LogicalVolumeDict,
NASShareDict,
PhysicalDiskDict,
ReplicationJobDict,
StorageQuotaDict,
StorageServiceDict,
VolumeSnapshotDict,
)
from napalm_linux.linux import LinuxDriver
from napalm_openmediavault._local_accounts import OmvLocalAccountsMixin
logger = logging.getLogger(__name__)
#: One label of a hostname (RFC 1123); OMV's own schema asks the same.
_HOSTNAME_LABEL_RE = re.compile(r"^(?!-)[A-Za-z0-9-]{1,63}(?<!-)$")
#: The modules OMV regenerates from ``conf.system.network.dns``. One already
#: dirty before the rename is applied with it, or the new name would not reach it.
_HOSTNAME_MODULES = frozenset(
{"hostname", "hosts", "postfix", "avahi", "samba", "proftpd", "systemdnetworkd"}
)
_DIRTY_MODULES = "/var/lib/openmediavault/dirtymodules.json"
#: Identity, overall health verdict and attributes; ``-H`` alone prints the verdict.
_SMARTCTL = "smartctl -iHA /dev/{name} 2>/dev/null"
#: The overall verdict of an ATA or NVMe disk: ``PASSED`` or ``FAILED!``.
_SMART_VERDICT_RE = re.compile(r"^SMART overall-health self-assessment test result:\s*(\S+)", re.M)
#: A SCSI/SAS disk's: ``OK``, or the failure it predicts.
_SMART_SCSI_STATUS_RE = re.compile(r"^SMART Health Status:\s*(.+?)\s*$", re.M)
_SMART_VERDICTS = {"PASSED": "healthy", "FAILED": "failed"}
#: An ATA disk's temperature attribute, an NVMe disk's ``Temperature:`` line.
_SMART_TEMP_RE = re.compile(
r"(?:Temperature_Celsius|Current Temperature|Temperature:)[^\n]*?(\d+)\s*(?:Celsius|\(|$)"
)
#: A SCSI/SAS disk's; a QEMU disk without a sensor prints ``0 C``.
_SMART_SCSI_TEMP_RE = re.compile(r"^Current Drive Temperature:\s+(\d+) C\s*$", re.M)
#: An md array's line in /proc/mdstat, and its members: ``sda1[0]``, ``sdc1[1](F)``.
_MDSTAT_ARRAY_RE = re.compile(r"^(md\d+)\s*:(.*)$", re.M)
_MDSTAT_MEMBER_RE = re.compile(r"(\S+?)\[\d+\]")
def smart_health(output: str) -> str:
"""The overall SMART verdict in ``smartctl -H`` output.
``"healthy"`` or ``"failed"``; ``"unknown"`` when smartctl printed none (no
SMART support, a USB bridge without pass-through).
"""
verdict = _SMART_VERDICT_RE.search(output)
if verdict:
return _SMART_VERDICTS.get(verdict.group(1).rstrip("!"), "unknown")
status = _SMART_SCSI_STATUS_RE.search(output)
if status:
return "healthy" if status.group(1) == "OK" else "failed"
return "unknown"
def smart_temperature(output: str) -> int:
"""A disk's temperature in Celsius from ``smartctl -A`` output; ``-1`` if none."""
found = _SMART_TEMP_RE.search(output)
if found:
return int(found.group(1))
scsi = _SMART_SCSI_TEMP_RE.search(output)
if scsi and int(scsi.group(1)) > 0:
return int(scsi.group(1))
return -1
def md_members(mdstat: str) -> dict[str, str]:
"""Each member device in ``/proc/mdstat``, mapped to its array: ``{"sda1": "md1"}``."""
return {
member: array
for array, rest in _MDSTAT_ARRAY_RE.findall(mdstat)
for member in _MDSTAT_MEMBER_RE.findall(rest)
}
def _pool_of(disk: str, members: dict[str, str]) -> str:
"""The array *disk* or one of its partitions is a member of, or ``""``.
Linux names a partition by appending its number, after a ``p`` when the disk's
name ends in a digit: ``sda`` owns ``sda1``, ``nvme0n1`` owns ``nvme0n1p1``;
``sdaa1`` is not ``sda``'s, nor ``nvme0n11`` (another namespace) ``nvme0n1``'s.
"""
partition = r"p\d+" if disk[-1:].isdigit() else r"\d+"
own = re.compile(rf"{re.escape(disk)}(?:{partition})?")
return next((array for member, array in members.items() if own.fullmatch(member)), "")
class OpenMediaVaultDriver(OmvLocalAccountsMixin, StorageDriver, LinuxDriver):
"""NAPALM driver for OpenMediaVault NAS systems.
Declares both roles it fills: a NAS built on Debian. Storage comes first,
so netOrk shows it as storage rather than as a Linux host.
Inherits all Linux OS functionality from LinuxDriver (packages, services,
users, processes, cron, Docker) -- OMV really is Debian, so apt applies --
and adds OMV-specific storage management on top.
NAS services are ``get_storage_services()``; the systemd service list stays
``get_services()``. Two names for two different things.
"""
TYPE_LABEL = "Storage"
DRIVER_NAME = "openmediavault"
#: "Upgrade everything" must be a full upgrade: OMV's own packages and the
#: kernel are held back by a plain ``apt-get upgrade`` (``omv-upgrade`` is a
#: dist-upgrade). netOrk reads this when it upgrades the host.
FULL_UPGRADE = True
driver_name = "openmediavault"
SSH_FINGERPRINT = [
FingerprintRule("debian", weight=4.0),
]
HTTP_FINGERPRINT = [
FingerprintRule("openmediavault", weight=9.0, mandatory=True),
]
#: OMV generates sshd_config from its own database; a drop-in netOrk wrote
#: would be dropped on the next apply of the SSH settings. Inherited from
#: napalm-linux, so opted out here (NetOrk/netork#1027).
harden_ssh_server = None # type: ignore[assignment]
# ── Facts override ─────────────────────────────────────────────────────────
def get_facts(self) -> dict[str, Any]:
"""Return device facts, overriding OMV version from dpkg."""
facts = super().get_facts()
try:
ver = self._send("dpkg-query -W -f='${Version}' openmediavault 2>/dev/null").strip()
if ver:
facts["os_version"] = f"OMV {ver}"
except Exception:
logger.debug("%s: OMV version not read: ignored", self.hostname, exc_info=True)
return facts
# ── Hostname ───────────────────────────────────────────────────────────────
def set_hostname(self, new_hostname: str) -> None:
"""Rename the NAS the way OMV's web UI does, through its own database.
LinuxDriver's rename writes ``/etc/hostname`` and ``/etc/hosts``, which
OMV regenerates from ``conf.system.network.dns`` on its next apply. So the
name goes to ``Network.setGeneralSettings`` -- an FQDN sets the domain as
well, a bare name keeps it -- and ``Config.applyChanges`` deploys the
modules the rename made dirty, plus the hostname modules that already
were. Other changes pending in the web UI stay pending.
:raises ValueError: for a name that is not a valid hostname, before
anything runs on the NAS.
:raises RuntimeError: when OMV refuses a step.
"""
labels = new_hostname.split(".")
if len(new_hostname) > 253 or not all(_HOSTNAME_LABEL_RE.match(x) for x in labels):
raise ValueError(f"not a valid hostname: {new_hostname!r}")
current = self._omv_rpc("Network", "getGeneralSettings")
domain = ".".join(labels[1:]) if len(labels) > 1 else current.get("domainname", "")
before = set(self._omv_dirty_modules())
self._omv_rpc(
"Network", "setGeneralSettings", {"hostname": labels[0], "domainname": domain}
)
after = set(self._omv_dirty_modules())
modules = sorted((after - before) | (after & _HOSTNAME_MODULES))
if modules:
# Salt restarts what it deploys (Samba, Postfix, networkd): give it time.
self._omv_rpc("Config", "applyChanges", {"modules": modules, "force": False}, 600)
def _omv_rpc(
self, service: str, method: str, params: dict[str, Any] | None = None, timeout: float = 60
) -> Any:
"""Call ``omv-rpc`` as root and return its decoded answer.
:raises RuntimeError: when the call fails, with OMV's answer.
"""
command = f"omv-rpc -u admin {service} {method}"
if params is not None:
command += f" {_shlex_quote(_json.dumps(params))}"
output, status = self._sudo_status(command, timeout)
if status != 0:
raise RuntimeError(f"omv-rpc {service}.{method} failed: {output[-300:]}")
lines = output.splitlines()
return _json.loads(lines[-1]) if lines else None
def _omv_dirty_modules(self) -> list[str]:
"""The modules with configuration changes not yet deployed."""
output, _status = self._sudo_status(f"cat {_DIRTY_MODULES} 2>/dev/null || echo '[]'", 30)
try:
dirty = _json.loads(output or "[]")
except ValueError:
return []
return [m for m in dirty if isinstance(m, str)] if isinstance(dirty, list) else []
# ── Physical disks ─────────────────────────────────────────────────────────
def get_disks(self) -> list[PhysicalDiskDict]:
"""Return physical disk inventory.
Uses ``lsblk -J`` for device enumeration, ``smartctl -iHA`` (via sudo)
for health, temperature, and RPM data, and ``/proc/mdstat``, read once,
for array membership.
Each entry contains:
* slot (string) - device path, e.g. ``"/dev/sda"``
* model (string) - drive model string
* serial (string) - drive serial number
* vendor (string) - drive manufacturer
* type (string) - ``"hdd"``, ``"ssd"``, or ``"nvme"``
* size (int) - raw capacity in bytes
* rpm (int) - rotational speed; ``0`` for SSD/NVMe
* temperature (int) - temperature in Celsius; ``-1`` if unavailable
* health (string) - ``"healthy"``, ``"failed"``, or ``"unknown"``
* pool (string) - md array name if member; empty string otherwise
Example::
[
{
"slot": "/dev/sda",
"model": "HGST HUS726T6TALE6L4",
"serial": "K3GXXXXX",
"vendor": "HGST",
"type": "hdd",
"size": 6001175126016,
"rpm": 7200,
"temperature": 34,
"health": "healthy",
"pool": "md1",
},
]
"""
result: list[PhysicalDiskDict] = []
try:
raw = self._send(
"lsblk -J -b -o NAME,SIZE,TYPE,ROTA,VENDOR,MODEL,SERIAL,TRAN 2>/dev/null"
)
lsblk = _json.loads(raw)
except Exception:
return result
members = self._md_members()
for dev in lsblk.get("blockdevices", []):
if dev.get("type") != "disk":
continue
name = dev.get("name", "")
if not name:
continue
size = int(dev.get("size") or 0)
rota = str(dev.get("rota", "1"))
vendor = (dev.get("vendor") or "").strip()
model = (dev.get("model") or "").strip()
serial = (dev.get("serial") or "").strip()
tran = (dev.get("tran") or "").strip().lower()
if tran == "nvme":
disk_type = "nvme"
elif rota == "0":
disk_type = "ssd"
else:
disk_type = "hdd"
health, temperature, rpm = self._smart(name, disk_type)
result.append(
PhysicalDiskDict(
slot=f"/dev/{name}",
model=model,
serial=serial,
vendor=vendor,
type=disk_type,
size=size,
rpm=rpm,
temperature=temperature,
health=health,
pool=_pool_of(name, members),
)
)
return result
def _smart(self, name: str, disk_type: str) -> tuple[str, int, int]:
"""A disk's SMART health, temperature (``-1`` if unknown) and rpm (``0``)."""
health, temperature, rpm = "unknown", -1, 0
try:
smart = self._sudo(_SMARTCTL.format(name=name), read_timeout=15)
health = smart_health(smart)
temperature = smart_temperature(smart)
if disk_type == "hdd":
rpm_m = re.search(r"Rotation Rate:\s+(\d+)\s+rpm", smart)
if rpm_m:
rpm = int(rpm_m.group(1))
except Exception:
logger.debug("%s: smartctl for %s: ignored", self.hostname, name, exc_info=True)
return health, temperature, rpm
def _md_members(self) -> dict[str, str]:
"""The md array of each member device, from one read of ``/proc/mdstat``."""
try:
return md_members(self._send("cat /proc/mdstat 2>/dev/null"))
except Exception:
logger.debug("%s: /proc/mdstat not read: ignored", self.hostname, exc_info=True)
return {}
# ── md RAID pools ──────────────────────────────────────────────────────────
def get_disk_pools(self) -> dict[str, DiskPoolDict]:
"""Return md RAID array status from ``/proc/mdstat`` and ``mdadm --detail``.
Keys are array names (e.g. ``"md1"``). Each value contains:
* name (string) - array name
* type (string) - always ``"md"``
* level (string) - RAID level, e.g. ``"raid1"``, ``"raid5"``
* status (string) - ``"online"``, ``"degraded"``, ``"faulted"``, or ``"offline"``
* total (int) - usable array size in bytes (``0`` if mdadm unavailable)
* used (int) - always ``0`` (use ``get_volumes()`` for per-filesystem usage)
* available (int) - always ``0``
* disks (list of strings) - member device names (e.g. ``["sda1", "sdb1"]``)
* auto_expand (bool) - always ``False`` (not applicable for md)
* dedup (bool) - always ``False``
* compression (string) - always ``"off"``
Example::
{
"md1": {
"name": "md1",
"type": "md",
"level": "raid1",
"status": "online",
"total": 2000398925824,
"used": 0,
"available": 0,
"disks": ["sda1", "sdb1"],
"auto_expand": False,
"dedup": False,
"compression": "off",
},
}
"""
result: dict[str, DiskPoolDict] = {}
try:
mdstat = self._send("cat /proc/mdstat 2>/dev/null")
except Exception:
return result
for line in mdstat.splitlines():
m = re.match(r"^(md\d+)\s*:\s+(\S+)\s+(\S+)\s+(.*)", line)
if not m:
continue
md_name, state_word, level_raw, members_raw = m.groups()
member_disks = re.findall(r"(\w+)\[\d+\]", members_raw)
status = "online" if state_word == "active" else "offline"
total = 0
try:
detail = self._sudo(f"mdadm --detail /dev/{md_name} 2>/dev/null", read_timeout=10)
size_m = re.search(r"Array Size\s*:\s*(\d+)\s*\(", detail)
if size_m:
total = int(size_m.group(1)) * 1024 # kB → bytes
if "degraded" in detail.lower():
status = "degraded"
elif re.search(r"State\s*:.*(?:faulty|failed)", detail, re.IGNORECASE):
status = "faulted"
except Exception:
logger.debug(
"%s: mdadm --detail for %s: ignored", self.hostname, md_name, exc_info=True
)
result[md_name] = DiskPoolDict(
name=md_name,
type="md",
level=level_raw.lower(),
status=status,
total=total,
used=0,
available=0,
disks=member_disks,
auto_expand=False,
dedup=False,
compression="off",
)
return result
# ── Logical volumes / filesystems ──────────────────────────────────────────
def get_volumes(self) -> dict[str, LogicalVolumeDict]:
"""Return mounted filesystem info from ``df``.
Only real block devices (``/dev/…``) are included; tmpfs, devtmpfs,
overlays, and similar pseudo-filesystems are skipped.
Keys are derived from the mountpoint (e.g. ``"srv-dev-disk-by-label-data"``
for ``/srv/dev/disk/by-label/data``; ``"root"`` for ``/``).
Each value contains:
* name (string) - key repeated for convenience
* pool (string) - device name without ``/dev/`` prefix
* type (string) - always ``"filesystem"``
* total (int) - total size in bytes
* used (int) - used space in bytes
* available (int) - available space in bytes
* mountpoint (string) - absolute mount path
* compression (string) - always ``"off"``
* dedup (bool) - always ``False``
* readonly (bool) - ``True`` if mounted ``ro``
* snapshots (int) - always ``0``
Example::
{
"srv-data": {
"name": "srv-data",
"pool": "md1",
"type": "filesystem",
"total": 2000398925824,
"used": 945000000000,
"available": 1055398925824,
"mountpoint": "/srv/data",
"compression": "off",
"dedup": False,
"readonly": False,
"snapshots": 0,
},
}
"""
result: dict[str, LogicalVolumeDict] = {}
try:
df_out = self._send("df -Pk 2>/dev/null")
except Exception:
return result
try:
mounts = self._send("cat /proc/mounts 2>/dev/null")
except Exception:
mounts = ""
for line in df_out.splitlines()[1:]:
parts = line.split()
if len(parts) < 6:
continue
device = parts[0]
total_k, used_k, avail_k = int(parts[1]), int(parts[2]), int(parts[3])
mountpoint = parts[5]
if not device.startswith("/dev/"):
continue
key = mountpoint.lstrip("/").replace("/", "-") or "root"
pool = device.removeprefix("/dev/")
readonly = bool(
re.search(
rf"^{re.escape(device)}\s+\S+\s+\S+\s+(?:[^,\s]*,)*ro(?:,|\s|$)",
mounts,
re.MULTILINE,
)
)
result[key] = LogicalVolumeDict(
name=key,
pool=pool,
type="filesystem",
total=total_k * 1024,
used=used_k * 1024,
available=avail_k * 1024,
mountpoint=mountpoint,
compression="off",
dedup=False,
readonly=readonly,
snapshots=0,
)
return result
# ── NAS shares ────────────────────────────────────────────────────────────
def get_shares(self) -> dict[str, NASShareDict]:
"""Return all configured NAS shares from the OMV config database.
Covers SMB/CIFS, NFS, and FTP shares. Keys are prefixed with the
protocol (e.g. ``"smb:media"``, ``"nfs:backups"``, ``"ftp:upload"``).
Each value contains:
* name (string) - share name without protocol prefix
* protocol (string) - ``"smb"``, ``"nfs"``, or ``"ftp"``
* path (string) - absolute filesystem path
* volume (string) - last path component (leaf directory)
* enabled (bool) - whether the share is currently exported
* readonly (bool) - whether the share is exported read-only
* description (string) - human-readable comment (SMB only)
* clients (list of strings) - allowed client addresses (NFS only)
Example::
{
"smb:media": {
"name": "media",
"protocol": "smb",
"path": "/srv/dev/disk/by-label/data/media",
"volume": "media",
"enabled": True,
"readonly": False,
"description": "Media library",
"clients": [],
},
"nfs:backups": {
"name": "backups",
"protocol": "nfs",
"path": "/srv/dev/disk/by-label/data/backups",
"volume": "backups",
"enabled": True,
"readonly": False,
"description": "",
"clients": ["192.168.1.0/24"],
},
}
"""
shares: dict[str, NASShareDict] = {}
shares.update(self._smb_shares())
shares.update(self._nfs_shares())
shares.update(self._ftp_shares())
return shares
# ── Storage services ──────────────────────────────────────────────────────
def get_storage_services(self) -> dict[str, StorageServiceDict]:
"""Return status of key NAS services (SMB, NFS, FTP, SSH, rsync).
This method is separate from ``get_services()`` (inherited from
LinuxDriver) which returns the full systemd service list.
Keys are service names. Each value contains:
* name (string) - service name
* enabled (bool) - configured to start on boot
* running (bool) - currently active
* port (int) - primary listening port
* version (string) - protocol version; empty if unknown
Example::
{
"smb": {"name": "smb", "enabled": True, "running": True,
"port": 445, "version": ""},
"nfs": {"name": "nfs", "enabled": True, "running": True,
"port": 2049, "version": ""},
"ftp": {"name": "ftp", "enabled": False, "running": False,
"port": 21, "version": ""},
"ssh": {"name": "ssh", "enabled": True, "running": True,
"port": 22, "version": ""},
"rsync": {"name": "rsync", "enabled": False, "running": False,
"port": 873, "version": ""},
}
"""
_SVC_MAP = [
# (key, systemd unit, default port)
("smb", "smbd", 445),
("nfs", "nfs-server", 2049),
("ftp", "proftpd", 21),
("ssh", "ssh", 22),
("rsync", "rsync", 873),
]
result: dict[str, StorageServiceDict] = {}
for key, unit, port in _SVC_MAP:
try:
running = (
self._send(f"systemctl is-active {unit} 2>/dev/null || true").strip()
== "active"
)
enabled = (
self._send(f"systemctl is-enabled {unit} 2>/dev/null || true").strip()
== "enabled"
)
except Exception:
running = enabled = False
result[key] = StorageServiceDict(
name=key,
enabled=enabled,
running=running,
port=port,
version="",
)
return result
# ── Not implemented ────────────────────────────────────────────────────────
def get_volume_snapshots(self, volume: str = "") -> list[VolumeSnapshotDict]:
"""Return volume snapshots (not supported on OpenMediaVault)."""
raise NotImplementedError("OpenMediaVault does not expose volume snapshots via this driver")
def get_replication_jobs(self) -> list[ReplicationJobDict]:
"""Return replication jobs (not supported on OpenMediaVault)."""
raise NotImplementedError
def get_quotas(self) -> list[StorageQuotaDict]:
"""Return storage quotas (not supported on OpenMediaVault)."""
raise NotImplementedError
# ── Internal helpers ───────────────────────────────────────────────────────
def _omv_read(self, key: str) -> list[dict[str, Any]]:
"""Query the OMV config database and return a list of objects.
Handles both OMV 6+ (returns a JSON array directly) and older
versions that wrap the array in a dict under a common key.
"""
try:
raw = self._send(f"omv-confdbadm read {key!r} 2>/dev/null").strip()
if not raw:
return []
data = _json.loads(raw)
if isinstance(data, list):
return data
# Older OMV wraps the list: {"share": [...]}
for wrapper in ("share", "rule", "entry", "mntent", "sharedfolder"):
if wrapper in data and isinstance(data[wrapper], list):
wrapped: list[dict[str, Any]] = data[wrapper]
return wrapped
return []
except Exception:
return []
def _resolve_shared_folder(self, uuid: str) -> str:
"""Resolve an OMV shared folder UUID to its absolute filesystem path."""
if not uuid:
return ""
try:
for folder in self._omv_read("conf.system.sharedfolder"):
if folder.get("uuid") != uuid:
continue
rel = folder.get("reldirpath", "").strip("/")
mnt_uuid = folder.get("mntentref", "")
mnt_dir = ""
for mntent in self._omv_read("conf.system.filesystem.mountpoint"):
if mntent.get("uuid") == mnt_uuid:
mnt_dir = mntent.get("dir", "").rstrip("/")
break
return f"{mnt_dir}/{rel}".rstrip("/") if rel else mnt_dir
except Exception:
logger.debug("%s: shared folder %s: ignored", self.hostname, uuid, exc_info=True)
return ""
def _smb_shares(self) -> dict[str, NASShareDict]:
out: dict[str, NASShareDict] = {}
for s in self._omv_read("conf.service.smb.shares"):
name = s.get("name", "")
if not name:
continue
path = self._resolve_shared_folder(s.get("sharedfolderref", ""))
out[f"smb:{name}"] = NASShareDict(
name=name,
protocol="smb",
path=path,
volume=path.split("/")[-1] if path else "",
enabled=bool(s.get("enable", True)),
readonly=bool(s.get("readonly", False)),
description=s.get("comment", ""),
clients=[],
)
return out
def _nfs_shares(self) -> dict[str, NASShareDict]:
out: dict[str, NASShareDict] = {}
for s in self._omv_read("conf.service.nfs.shares"):
path = self._resolve_shared_folder(s.get("sharedfolderref", ""))
name = path.split("/")[-1] or s.get("sharedfolderref", "")
clients_raw = s.get("client", "") or ""
clients = [c.strip() for c in clients_raw.split(",") if c.strip()]
opts = s.get("options", "") or ""
out[f"nfs:{name}"] = NASShareDict(
name=name,
protocol="nfs",
path=path,
volume=path.split("/")[-1] if path else "",
enabled=bool(s.get("enable", True)),
readonly="ro" in [o.strip() for o in opts.split(",")],
description="",
clients=clients,
)
return out
def _ftp_shares(self) -> dict[str, NASShareDict]:
out: dict[str, NASShareDict] = {}
for s in self._omv_read("conf.service.ftp.shares"):
path = self._resolve_shared_folder(s.get("sharedfolderref", ""))
name = path.split("/")[-1] or s.get("sharedfolderref", "")
out[f"ftp:{name}"] = NASShareDict(
name=name,
protocol="ftp",
path=path,
volume=path.split("/")[-1] if path else "",
enabled=bool(s.get("enable", True)),
readonly=bool(s.get("readonly", False)),
description="",
clients=[],
)
return out