qnap-tools 0.4.0__py3-none-any.whl

qnap_tools/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""Servidores MCP de solo lectura para consultar una flota de NAS QNAP por SSH."""
+
+__version__ = "0.4.0"

qnap_tools/claves.py

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+"""Par de claves SSH de este ordenador (ed25519), en la carpeta de datos del plugin.
+
+Cada ordenador tiene su propia clave privada, que no sale de el; lo que se instala en los
+NAS es la parte publica. La proteccion de la privada es la de la carpeta de datos (el perfil
+del usuario); en sistemas POSIX se crea ademas con permisos 600.
+"""
+import os
+import re
+import socket
+
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
+
+
+def _comentario():
+    equipo = re.sub(r"[^A-Za-z0-9_.-]", "-", socket.gethostname() or "equipo")[:60]
+    return "qnap-tools@" + equipo
+
+
+def asegurar(cfg) -> str:
+    """Crea el par si no existe y devuelve la linea publica (tipo, clave y comentario)."""
+    ruta_privada = cfg.clave
+    ruta_publica = ruta_privada.with_name(ruta_privada.name + ".pub")
+    if ruta_privada.exists():
+        privada = serialization.load_ssh_private_key(ruta_privada.read_bytes(), password=None)
+    else:
+        ruta_privada.parent.mkdir(parents=True, exist_ok=True)
+        privada = Ed25519PrivateKey.generate()
+        cuerpo = privada.private_bytes(
+            serialization.Encoding.PEM, serialization.PrivateFormat.OpenSSH,
+            serialization.NoEncryption())
+        # O_EXCL: si otro proceso la acaba de crear, no se pisa
+        fd = os.open(str(ruta_privada), os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+        with os.fdopen(fd, "wb") as f:
+            f.write(cuerpo)
+    publica = privada.public_key().public_bytes(
+        serialization.Encoding.OpenSSH, serialization.PublicFormat.OpenSSH).decode("ascii")
+    if ruta_publica.exists():
+        # se conserva la linea ya escrita (y su comentario) mientras sea de esta clave:
+        # es la que esta instalada en los NAS
+        linea = ruta_publica.read_text(encoding="utf-8").strip()
+        if linea.startswith(publica + " "):
+            return linea
+    linea = "%s %s" % (publica, _comentario())
+    ruta_publica.write_text(linea + "\n", encoding="utf-8")
+    return linea

qnap_tools/comandos.py

@@ -0,0 +1,139 @@
+# -*- coding: utf-8 -*-
+"""Comandos de plantilla fija: lo unico que se ejecuta en un NAS.
+
+Cada orden que lanza una herramienta es un Comando definido en el codigo. No hay comando
+libre. Los parametros que entran en una plantilla se validan contra un tipo estricto y se
+entrecomillan; una plantilla que escribe en un fichero o lleva sudo no se puede ni definir
+(el sudo lo anade el transporte en los comandos marcados).
+"""
+import re
+import shlex
+from dataclasses import dataclass, field
+from typing import Callable, Mapping
+
+# Tipos de parametro. Se comparan con fullmatch (un $ dejaria pasar un salto de linea final)
+# y ninguno admite empezar por "-", para que un valor no pueda colarse como opcion.
+TIPOS = {
+    "interfaz": re.compile(r"[A-Za-z0-9][A-Za-z0-9_.@:-]{0,31}"),
+    "destino": re.compile(r"[A-Za-z0-9]([A-Za-z0-9.:-]{0,251}[A-Za-z0-9])?"),
+    "entero": re.compile(r"[0-9]{1,6}"),
+    "bahia": re.compile(r"[0-9]{1,3}"),
+    "uuid": re.compile(r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}"),
+    "nombre": re.compile(r"[A-Za-z0-9][A-Za-z0-9_.-]{0,127}"),
+    "fecha": re.compile(r"[0-9]{4}-[0-9]{2}-[0-9]{2}"),
+    "md": re.compile(r"md[0-9]{1,3}"),          # grupo RAID del kernel: /dev/md1
+    "nvme": re.compile(r"nvme[0-9]{1,2}"),      # controladora NVMe: /dev/nvme0
+    # texto que se busca en un registro: letras (tambien con acento), cifras, espacio y
+    # _ . : @ / -; nada que cierre una comilla, encadene una orden o haga de comodin
+    "palabra": re.compile(r"\w[\w .:@/-]{0,38}[\w.:@/-]"),
+    "nivel": re.compile(r"[0-7]"),               # nivel de un mensaje del kernel
+}
+SISTEMAS = ("ambos", "hero", "qts")
+
+MARCADOR = re.compile(r"\{([a-z_][a-z0-9_]*)\}")
+REDIRECCION_INOCUA = re.compile(r"2>&1|2>\s*/dev/null|(?<![0-9&>])>\s*/dev/null")
+SUDO = re.compile(r"\bsudo\b")
+
+
+class ParametroInvalido(ValueError):
+    pass
+
+
+# --- validadores de salida: None si vale, o el texto del error -------------------
+
+def rc_cero(rc: int, salida: str):
+    if rc != 0:
+        return "el comando termino con codigo %d" % rc
+    return None
+
+
+def no_vacia(rc: int, salida: str):
+    if not salida.strip():
+        return "el comando no devolvio nada"
+    return None
+
+
+def todas(*validadores):
+    def valida(rc, salida):
+        for v in validadores:
+            error = v(rc, salida)
+            if error:
+                return error
+        return None
+    return valida
+
+
+def sin_centinela(*centinelas):
+    """Error si la salida esta vacia o solo trae valores centinela (p. ej. '0 C', '--').
+
+    Varias utilidades de QNAP devuelven eso con codigo 0 cuando les falta sudo.
+    """
+    def valida(rc, salida):
+        lineas = [linea.strip() for linea in salida.splitlines() if linea.strip()]
+        if not lineas:
+            return "el comando no devolvio nada"
+        if all(linea in centinelas for linea in lineas):
+            return "el comando devolvio un valor vacio (%s)" % lineas[0]
+        return None
+    return valida
+
+
+estricta = todas(rc_cero, no_vacia)
+
+
+@dataclass(frozen=True)
+class Comando:
+    id: str
+    plantilla: str
+    params: Mapping[str, str] = field(default_factory=dict)
+    sudo: bool = False
+    timeout: int = 20
+    sistema: str = "ambos"
+    # Por defecto, codigo 0 y salida no vacia. valida=None lo desactiva de forma explicita.
+    valida: Callable[[int, str], str | None] | None = estricta
+    no_probado: bool = False
+
+    def __post_init__(self):
+        if not self.id:
+            raise ValueError("comando sin identificador")
+        p = self.plantilla
+        if "\n" in p or "\r" in p or "`" in p:
+            raise ValueError("comando %s: saltos de linea y comillas invertidas no admitidos" % self.id)
+        if SUDO.search(p):
+            raise ValueError("comando %s: la plantilla no lleva sudo; se marca con sudo=True" % self.id)
+        if ">" in REDIRECCION_INOCUA.sub(" ", p):
+            raise ValueError("comando %s: la plantilla redirige a un fichero" % self.id)
+        usados = set(MARCADOR.findall(p))
+        declarados = set(self.params)
+        if usados - declarados:
+            raise ValueError("comando %s: marcador sin declarar: %s"
+                             % (self.id, ", ".join(sorted(usados - declarados))))
+        if declarados - usados:
+            raise ValueError("comando %s: parametro declarado que no se usa: %s"
+                             % (self.id, ", ".join(sorted(declarados - usados))))
+        for nombre, tipo in self.params.items():
+            if tipo not in TIPOS:
+                raise ValueError("comando %s: tipo de parametro desconocido: %s" % (self.id, tipo))
+        if self.sistema not in SISTEMAS:
+            raise ValueError("comando %s: sistema desconocido: %s" % (self.id, self.sistema))
+        if type(self.timeout) is not int or self.timeout <= 0:
+            raise ValueError("comando %s: timeout no valido: %r" % (self.id, self.timeout))
+
+    def render(self, valores: Mapping[str, object] | None = None) -> str:
+        valores = dict(valores or {})
+        faltan = sorted(set(self.params) - set(valores))
+        if faltan:
+            raise ParametroInvalido("falta el parametro %s" % ", ".join(faltan))
+        sobran = sorted(set(valores) - set(self.params))
+        if sobran:
+            raise ParametroInvalido("parametro no admitido: %s" % ", ".join(sobran))
+        listos = {}
+        for nombre, tipo in self.params.items():
+            valor = valores[nombre]
+            if type(valor) is int:
+                valor = str(valor)
+            if not isinstance(valor, str) or not TIPOS[tipo].fullmatch(valor):
+                raise ParametroInvalido(
+                    "parametro %s no valido (se esperaba %s): %s" % (nombre, tipo, repr(valor)[:60]))
+            listos[nombre] = shlex.quote(valor)
+        return MARCADOR.sub(lambda m: listos[m.group(1)], self.plantilla)

qnap_tools/config.py

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+"""Configuracion de los servidores: credencial comun y carpeta de datos, leidas del entorno.
+
+El plugin de Claude Code pasa la credencial por variables de entorno (userConfig -> env).
+La contrasena no se escribe nunca en disco ni aparece en repr().
+"""
+import os
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Mapping
+
+# Un marcador ${...} que ha llegado sin sustituir no es un valor
+SIN_SUSTITUIR = re.compile(r"\$\{[A-Za-z_][A-Za-z0-9_.]*\}")
+
+
+class ConfigError(Exception):
+    pass
+
+
+@dataclass(frozen=True)
+class Config:
+    usuario: str
+    contrasena: str = field(repr=False)
+    datos: Path
+    inventario: Path
+    clave: Path
+    known_hosts: Path
+
+
+def _valor(entorno, nombre):
+    v = entorno.get(nombre)
+    if not v or SIN_SUSTITUIR.fullmatch(v.strip()):
+        return None
+    return v
+
+
+def cargar(entorno: Mapping[str, str] = os.environ) -> Config:
+    usuario = (_valor(entorno, "QNAP_TOOLS_USER") or "").strip()
+    contrasena = _valor(entorno, "QNAP_TOOLS_PASSWORD")
+    faltan = [n for n, v in (("QNAP_TOOLS_USER", usuario), ("QNAP_TOOLS_PASSWORD", contrasena)) if not v]
+    if faltan:
+        raise ConfigError(
+            "falta configurar %s: en Claude Code, /plugin configure qnap-tools "
+            "(usuario SSH comun de la flota y su contrasena)" % " y ".join(faltan))
+    datos = Path(_valor(entorno, "QNAP_TOOLS_DATA") or _valor(entorno, "CLAUDE_PLUGIN_DATA")
+                 or Path.home() / ".qnap-tools")
+    inventario = _valor(entorno, "QNAP_TOOLS_INVENTARIO")
+    return Config(
+        usuario=usuario,
+        contrasena=contrasena,
+        datos=datos,
+        inventario=Path(inventario) if inventario else datos / "inventario.toml",
+        clave=datos / "id_ed25519",
+        known_hosts=datos / "known_hosts",
+    )

qnap_tools/deteccion.py

@@ -0,0 +1,79 @@
+# -*- coding: utf-8 -*-
+"""Perfil de un NAS: sistema (QuTS hero o QTS), modelo, firmware y paquetes instalados.
+
+Se averigua con una sola orden, sin sudo. Lo que cambia de un NAS a otro (sistema de
+almacenamiento, carpeta de cada paquete) se toma de aqui y nunca se fija en el codigo.
+"""
+import re
+from dataclasses import dataclass, field
+
+from .comandos import Comando
+
+PAQUETES = ("QKVM", "container-station")
+SISTEMAS = ("hero", "qts")
+RUTA_VALIDA = re.compile(r"/[A-Za-z0-9_./-]{1,200}")
+
+# La version sale de /etc/default_config: la de /etc/config puede quedarse obsoleta tras
+# una actualizacion (visto en un QuTS hero real). hero = hay ZFS.
+DETECCION = Comando(
+    "deteccion",
+    "echo sistema=$([ -x /sbin/zpool ] && echo hero || echo qts); "
+    "echo modelo=$(getcfg System Model -f /etc/default_config/uLinux.conf); "
+    "echo firmware=$(getcfg System Version -f /etc/default_config/uLinux.conf); "
+    "echo build=$(getcfg System 'Build Number' -f /etc/default_config/uLinux.conf); "
+    "echo nombre=$(hostname); "
+    "for q in %s; do "
+    "echo paquete.$q.enable=$(getcfg $q Enable -f /etc/config/qpkg.conf); "
+    "echo paquete.$q.ruta=$(getcfg $q Install_Path -f /etc/config/qpkg.conf); "
+    "done" % " ".join(PAQUETES),
+)
+
+
+class DeteccionFallida(Exception):
+    pass
+
+
+@dataclass(frozen=True)
+class Perfil:
+    sistema: str
+    modelo: str
+    firmware: str
+    build: str
+    nombre: str
+    paquetes: dict = field(default_factory=dict)
+    avisos: tuple = ()
+
+
+def detectar(con) -> Perfil:
+    r = con.ejecutar(DETECCION.render(), sudo=False, timeout=DETECCION.timeout)
+    if r.agotado:
+        raise DeteccionFallida(
+            "%s: no respondio a tiempo (%d s) al identificar el sistema" % (con.destino, DETECCION.timeout))
+    campos = {}
+    for linea in r.salida.splitlines():
+        if "=" in linea:
+            clave, valor = linea.split("=", 1)
+            campos[clave.strip()] = valor.strip()
+    if campos.get("sistema") not in SISTEMAS or not campos.get("firmware"):
+        raise DeteccionFallida(
+            "%s: no se pudo identificar el sistema del NAS (no parece un QNAP con QTS o QuTS hero)"
+            % con.destino)
+    paquetes = {}
+    avisos = []
+    for nombre in PAQUETES:
+        ruta = campos.get("paquete.%s.ruta" % nombre, "")
+        if campos.get("paquete.%s.enable" % nombre, "").upper() != "TRUE" or not ruta:
+            continue
+        if not RUTA_VALIDA.fullmatch(ruta) or ".." in ruta:
+            avisos.append("paquete %s: su ruta de instalacion no es valida y no se usara" % nombre)
+            continue
+        paquetes[nombre] = ruta
+    return Perfil(
+        sistema=campos["sistema"],
+        modelo=campos.get("modelo", ""),
+        firmware=campos["firmware"],
+        build=campos.get("build", ""),
+        nombre=campos.get("nombre", ""),
+        paquetes=paquetes,
+        avisos=tuple(avisos),
+    )

qnap_tools/discos/__init__.py

@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+"""Servidor qnap-discos: discos, almacenamiento y carpetas de los NAS, en solo lectura."""

qnap_tools/discos/comandos.py

@@ -0,0 +1,199 @@
+# -*- coding: utf-8 -*-
+"""Ordenes de la pata de discos y carpetas. Todas de solo lectura.
+
+Salen de la exploracion hecha contra NAS reales (pruebas/catalogo/discos*.json). Cada orden
+declara para que sistema vale: "ambos", "hero" (QuTS hero, ZFS) o "qts" (QTS, md y LVM).
+De los ficheros de configuracion se leen campos concretos, nunca el fichero entero.
+
+Un disco se identifica por cabina y bahia, los dos numeros que usa el propio NAS en sus
+ficheros (enclosure_<cabina>.conf, smart_<cabina>_<bahia>.info): la cabina 0 es el NAS.
+"""
+from ..comandos import Comando, no_vacia, rc_cero
+
+# --- discos fisicos ---------------------------------------------------------------------------
+
+# Siempre sin sudo: como root no termina en 40 s en un NAS con muchos discos.
+DISCOS_LISTA = Comando("discos_lista", "qcli_storage -d", timeout=30)
+DISCOS_REPARTO = Comando("discos_reparto", "qcli_storage -p", timeout=30)
+
+# Ni los WWN ni las pruebas de velocidad que el NAS guarda en el mismo fichero. El ultimo
+# fichero puede no tener discos (grep termina con 1): se valida la salida, no el codigo.
+CAMPOS_DISCO = ("port_id", "pd_sys_name", "type", "vendor", "model", "serial_no", "revision",
+                "capacity", "sector_size", "rotation_speed", "status")
+DISCOS_DETALLE = Comando(
+    "discos_detalle",
+    "for f in /etc/enclosure_*.conf; do echo \"== $f\"; grep -E '^\\[PhysicalDisk|^(%s) =' $f; done"
+    % "|".join(CAMPOS_DISCO),
+    valida=no_vacia)
+
+# Veredicto SMART del propio NAS para las bahias de la cabina principal. getsysinfo no termina
+# sus respuestas en salto de linea (de ahi un echo por valor) y sin privilegios responde
+# "0 C" y "--" con codigo 0: siempre con sudo, y el parser comprueba esos centinelas.
+MAX_BAHIAS = 32
+DISCOS_SALUD = Comando(
+    "discos_salud",
+    "n=$(getsysinfo hdnum); for b in %s; do [ $b -le $n ] && echo \"== $b\""
+    " && echo modelo=$(getsysinfo hdmodel $b) && echo temperatura=$(getsysinfo hdtmp $b)"
+    " && echo smart=$(getsysinfo hdsmart $b) && echo estado=$(getsysinfo hdstatus $b); done;"
+    " [ -n \"$n\" ]" % " ".join(str(b) for b in range(1, MAX_BAHIAS + 1)),
+    sudo=True, timeout=40)
+
+# --- SMART ------------------------------------------------------------------------------------
+
+# Los ficheros que el NAS refresca cada pocos minutos con los atributos de cada disco (tambien
+# de los NVMe y de las cabinas de expansion). La carpeta solo la lee root.
+SMART_TODOS = Comando(
+    "smart_todos",
+    "for f in /tmp/smart/smart_*.info; do [ -e $f ] && echo \"== $f\" && cat $f; done;"
+    " ls /tmp/smart/ >/dev/null",
+    sudo=True, timeout=30)
+SMART_ATRIBUTOS = Comando("smart_atributos", "cat /tmp/smart/smart_{cabina}_{bahia}.info",
+                          {"cabina": "bahia", "bahia": "bahia"}, sudo=True)
+# Avisos por valor que el usuario haya configurado en el NAS. Sin fichero no hay ninguno.
+SMART_UMBRALES = Comando(
+    "smart_umbrales",
+    "[ ! -e /tmp/smart_warning.conf ] || grep -E '^\\[|^(policy|enable|value) =' /tmp/smart_warning.conf",
+    valida=rc_cero)
+
+# Desgaste de cada SSD segun el NAS. Un NAS sin SSD no tiene ficheros, o ni la carpeta.
+SSD_VIDA = Comando(
+    "ssd_vida",
+    "for f in /tmp/disk/disk_*.info; do [ -e $f ] && echo \"== $f\" && grep -E '^SSD_LIFE_USED' $f; done;"
+    " [ ! -d /tmp/disk ] || ls /tmp/disk/ >/dev/null",
+    valida=rc_cero)
+
+# --- rendimiento ------------------------------------------------------------------------------
+
+# Dos lecturas de los contadores del kernel, cada una con su reloj (/proc/uptime) para saber
+# el intervalo real. Solo discos enteros: en QuTS hero el fichero trae un zd por volumen.
+_LECTURA = "cat /proc/uptime; grep -E ' (sd[a-z]+|nvme[0-9]+n[0-9]+) ' /proc/diskstats"
+DISKSTATS = Comando("diskstats", "%s; sleep 5; echo ==5s; %s" % (_LECTURA, _LECTURA), timeout=25)
+
+# --- QuTS hero: pools, datasets, instantaneas y LUN ---------------------------------------------
+
+# -H -p: sin cabecera, separado por tabuladores y con los tamanos en bytes. El ZFS de QNAP no
+# tiene la propiedad de fragmentacion.
+POOLS = Comando("pools", "zpool list -H -p -o name,size,alloc,free,cap,dedup,health", sistema="hero")
+POOLS_ESTADO = Comando("pools_estado", "zpool status -v", sistema="hero", timeout=30)
+DATASETS = Comando(
+    "datasets",
+    "zfs list -H -p -t filesystem,volume -o name,type,used,avail,refer,quota,refquota,compressratio,mountpoint,"
+    "compression,dedup,encryption,keystatus",
+    sistema="hero", timeout=30)
+# Todas, de la mas antigua a la mas reciente: el recorte y su cuenta los pone el servidor. Sin
+# tuberia, para que el codigo de salida sea el de zfs. Un NAS sin instantaneas no devuelve nada.
+SNAPSHOTS_HERO = Comando("zfs_snapshots", "zfs list -H -p -t snapshot -o name,used,refer,creation -s creation",
+                         sistema="hero", timeout=60, valida=rc_cero)
+# Todo menos "description", que es texto libre.
+CAMPOS_PROG_HERO = ("source_lv_id", "retention", "expiremin", "keepAmount", "hourAmount", "dayAmount",
+                    "weekAmount", "monthAmount", "normalAmount", "Schedule", "MonthDay", "WeekDay",
+                    "Dueday", "Frequency", "OnHour", "OnMinute", "OffHour", "OffMinute", "smart", "vital",
+                    "immutable", "snapshot_type", "schedule_status", "ScheduleTime", "lastRetentionTime")
+_PROG_HERO = "/etc/config/qsnapshot/zsnapshotSchedule.conf"
+SNAPSHOTS_PROG_HERO = Comando(
+    "zfs_snapshots_prog",
+    "[ ! -s %s ] || grep -E '^\\[|^(%s) =' %s" % (_PROG_HERO, "|".join(CAMPOS_PROG_HERO), _PROG_HERO),
+    sistema="hero", valida=rc_cero)
+# De los dos JSON de iSCSI (una clave por linea), solo estas claves: ni CHAP ni nada que no se
+# haya visto. grep -o saca la clave y su valor, no la linea: si el fichero viniera en una sola
+# linea no saldria nada (y la orden fallaria) en vez de salir entero. Ningun NAS de pruebas
+# tenia destinos ni LUN: sin validar.
+CLAVES_ISCSI_HERO = ("lun", "portal", "target", "initiator", "service_enable", "service_port",
+                     "iqn_prefix", "initiator_id", "name", "alias", "[0-9]+")
+LUNS_HERO = Comando(
+    "zfs_iscsi",
+    "for f in /etc/config/hero_zfs_lun.json /etc/config/hero_iscsi_scst.json; do"
+    " [ ! -s $f ] || echo \"== $f\"; [ ! -s $f ] ||"
+    " grep -o -E '^[[:space:]]*\"(%s)\":(\"[^\"]*\"|[a-z0-9.-]+|[{][}]?)' $f; done"
+    % "|".join(CLAVES_ISCSI_HERO),
+    sistema="hero", valida=rc_cero, no_probado=True)
+
+
+# --- QTS: grupos md, volumenes, pools ligeros, instantaneas e iSCSI -----------------------------
+
+def _campos_de(fichero, campos, secciones="^\\["):
+    """Orden que saca de un .conf sus cabeceras de seccion y solo estos campos. Sin fichero (o
+    vacio) no devuelve nada; si existe y no se puede leer, falla."""
+    return "[ ! -s %s ] || grep -E '%s|^(%s) ?=' %s" % (fichero, secciones, "|".join(campos), fichero)
+
+
+MDSTAT = Comando("mdstat", "cat /proc/mdstat", sistema="qts")
+# Un echo por valor: segun el nivel faltan ficheros (un raid0 no tiene sync_action) y cat
+# los saltaria, descolocando los demas. Un valor vacio es "no lo dice", no un cero.
+MD_SYS = Comando(
+    "md_sys",
+    "for d in /sys/block/md*/md; do echo \"== $d\"; echo nivel=$(cat $d/level 2>/dev/null);"
+    " echo estado=$(cat $d/array_state 2>/dev/null); echo accion=$(cat $d/sync_action 2>/dev/null);"
+    " echo degradado=$(cat $d/degraded 2>/dev/null);"
+    " echo discrepancias=$(cat $d/mismatch_cnt 2>/dev/null); done",
+    sistema="qts")
+# Los grupos que QTS considera suyos (los demas md son del sistema) y sus miembros por bahia.
+# grep -o: de "data_0 = 1, <WWN>" solo sale "data_0 = 1".
+RAID_CONF = Comando(
+    "raid_conf",
+    "[ ! -s /etc/config/raid.conf ] || grep -o -E '^\\[[A-Za-z0-9_]+\\]|^(id|deviceName|raidLevel) = .*"
+    "|^(data|spare)_[0-9]+ = [0-9A-Fa-f]+|^globalSpare[0-9]+ = [0-9A-Fa-f]+' /etc/config/raid.conf",
+    sistema="qts", valida=rc_cero)
+VOLUMENES_CONF = Comando(
+    "volumenes_conf",
+    _campos_de("/etc/volume.conf", ("volId", "volName", "raidId", "raidName", "encryption", "ssdCache",
+                                    "unclean", "mappingName", "readOnly", "status", "volType", "internal"),
+               secciones="^\\[VOL"),
+    sistema="qts", valida=rc_cero)
+LVM_CONF = Comando(
+    "lvm_conf",
+    _campos_de("/etc/config/qlvm.conf", ("poolId", "tpId", "poolName", "threshold", "overThreshold",
+                                         "snapshot_reserved", "memberId", "memberName", "tpName", "tpSize",
+                                         "metaSize", "lvId", "lvName", "lvSize", "volName")),
+    sistema="qts", valida=rc_cero)
+# status, nunca table: table ensena la clave de los volumenes cifrados.
+DM_ESTADO = Comando("dm_estado", "dmsetup status", sudo=True, sistema="qts")
+SNAPSHOTS_QTS = Comando(
+    "lvm_snapshots",
+    _campos_de("/etc/config/qsnapshot/snapshot.conf", ("Count", "snapshotId", "name", "size", "expiremin",
+                                                       "time", "vital", "snapshot_type", "replicated")),
+    sistema="qts", timeout=30, valida=rc_cero)
+CAMPOS_PROG_QTS = ("source_lv_id", "retention", "expiremin", "keepAmount", "hourAmount", "dayAmount",
+                   "weekAmount", "monthAmount", "normalAmount", "Schedule", "MonthDay", "WeekDay", "Hour",
+                   "Minute", "smart", "vital", "snapshot_type", "status", "schedule_status", "ScheduleTime",
+                   "lastRetentionTime")
+SNAPSHOTS_PROG_QTS = Comando(
+    "lvm_snapshots_prog", _campos_de("/etc/config/qsnapshot/snapshotSchedule.conf", CAMPOS_PROG_QTS),
+    sistema="qts", valida=rc_cero)
+# Servicio, iniciadores y, de destinos y LUN, nombre y estado. Las claves CHAP y la seccion de
+# claves de iniciador no estan en la lista. Ningun NAS de pruebas tenia destinos ni LUN: los
+# nombres de sus campos no se han podido comprobar.
+ISCSI_QTS = Comando(
+    "lvm_iscsi",
+    _campos_de("/etc/config/iscsi_trgt.conf", ("bServiceEnable", "servicePort", "targetIQNPrefix",
+                                               "initiatorIQN", "initiatorAlias", "targetIndex", "targetName",
+                                               "targetIQN", "targetAlias", "bTargetEnable", "targetStatus",
+                                               "LUNIndex", "LUNName", "LUNCapacity", "LUNStatus", "bLUNEnable")),
+    sistema="qts", valida=rc_cero, no_probado=True)
+
+
+# --- carpetas compartidas y ocupacion (los dos sistemas) ----------------------------------------
+
+# Solo los montajes de volumen (/share/<X>_DATA), una linea cada uno y en KiB. Con ellos como
+# argumentos df no consulta los demas montajes: una carpeta remota caida lo dejaria colgado, y
+# el df de QNAP (BusyBox) no tiene -l. Las carpetas de /share que no son un montaje salen como
+# el tmpfs de /share y el parser las descarta. Sin ningun volumen df termina con 1 y solo da la
+# cabecera: se valida la salida, y el parser exige esa cabecera.
+OCUPACION = Comando("ocupacion", "df -P -k /share/*_DATA", timeout=25, valida=no_vacia)
+# De smb.conf, las secciones y solo los campos de cada carpeta: quien entra y como. Sin este
+# fichero no hay "ninguna carpeta": es un fallo de lectura.
+CAMPOS_SMB = ("path", "comment", "valid users", "invalid users", "read list", "write list", "browsable",
+              "browseable", "guest ok", "recycle bin")
+CARPETAS_SMB = Comando(
+    "carpetas_smb",
+    "grep -E '^\\[|^[[:space:]]*(%s) *=' /etc/config/smb.conf" % "|".join(CAMPOS_SMB))
+# El uso de cada carpeta que el propio NAS calcula y guarda (no se recorre nada).
+CARPETAS_USO = Comando(
+    "carpetas_uso",
+    "[ ! -s /etc/config/volumeStatus.conf ] || grep -E"
+    " '^\\[|^(Used Size|Directory Count|File Count|Latest Update Time) *=' /etc/config/volumeStatus.conf",
+    valida=rc_cero)
+# Vacio o inexistente si no hay nada exportado por NFS. No lleva secretos.
+CARPETAS_NFS = Comando("carpetas_nfs", "[ ! -s /etc/exports ] || cat /etc/exports", valida=rc_cero)
+# Solo el primer nivel: cada carpeta compartida es un enlace a su volumen.
+CARPETAS_ENLACES = Comando("carpetas_enlaces", "ls -l /share/")