From ded19238c028b6ffef05ceed348c5f2240c8c879 Mon Sep 17 00:00:00 2001 From: Christian Manivong Date: Mon, 2 Nov 2026 09:18:50 +0100 Subject: [PATCH] fix(dal): raise on a failed request instead of reading it as empty _dal_query and _fetch_page returned None for any failure, and the getters turned that into empty data, so a timeout or an expired session read as a gateway with no hosts, port forwards, SSIDs or Wi-Fi clients. Both now raise: ConnectionException when the gateway does not answer or refuses the session, RuntimeError naming the request otherwise. A getter whose DAL request fails still reads the HTML page and raises when that fails too; get_facts no longer swallows a failed get_interfaces. Closes #15 --- CHANGELOG.md | 9 ++ napalm_zyxel/zyxel_driver.py | 188 ++++++++++++++++++----------------- tests/quality_baseline.json | 3 +- tests/test_failed_reads.py | 151 ++++++++++++++++++++++++++++ 4 files changed, 257 insertions(+), 94 deletions(-) create mode 100644 tests/test_failed_reads.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 2667cc9..12f48ad 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,6 +13,15 @@ All notable changes to this driver. The format follows 3.12 venv no longer has. ### Fixed +- A failed request to the gateway raises instead of reading as empty data (#15). A + timeout, a refused session or an HTTP error made `get_hosts`, `get_arp_table`, + `get_port_forwards`, `get_nat_translations`, `get_wireless_clients`, `get_ssids`, + `get_radio_status` and `get_diagnostics` report a gateway with nothing configured. + They raise `ConnectionException` when the gateway does not answer or refuses the + session (HTTP 401/403) and `RuntimeError` naming the request otherwise. A getter + whose DAL request fails still reads the HTML page, and raises when that fails too. + `get_facts` no longer reports an empty interface list when the interfaces cannot be + read, and `reboot_host` / `restart_wifi` raise the same way when the request fails. - `get_arp_table()` reports an unknown age as `-1.0` (napalm-device-types' `ARP_AGE_UNKNOWN`) instead of `0.0`, which means "confirmed just now": the host list says a host is active, not when the gateway last saw it (NetOrk/netork#1327). diff --git a/napalm_zyxel/zyxel_driver.py b/napalm_zyxel/zyxel_driver.py index a3132f3..94efb27 100644 --- a/napalm_zyxel/zyxel_driver.py +++ b/napalm_zyxel/zyxel_driver.py @@ -8,10 +8,12 @@ from __future__ import annotations import base64 import json +import logging import os import re import socket -from typing import Any +from collections.abc import Callable +from typing import Any, TypeVar from urllib.parse import urljoin import requests @@ -33,6 +35,13 @@ from napalm_device_types.models import ( WirelessClientDict, ) +logger = logging.getLogger(__name__) + +#: Answers that mean the session is not (or no longer) accepted. +_SESSION_REFUSED = (401, 403) + +_T = TypeVar("_T") + _PING_UNSUPPORTED = "Not supported on Zyxel VMG: the DAL does not report ping replies" @@ -238,7 +247,8 @@ class ZyxelVMGDriver(ResidentialGatewayDriver): except (requests.RequestException, json.JSONDecodeError, TypeError): return None - def _dal_query(self, oid: str, data: dict | None = None) -> dict | None: + def _dal_query(self, oid: str, data: dict | None = None) -> dict: + """The gateway's decrypted answer to DAL *oid*; a failed request raises (#15).""" if self._session is None or self._sessionkey is None or self._crypto is None: raise ConnectionClosedException("Not connected") if data is None: @@ -253,10 +263,11 @@ class ZyxelVMGDriver(ResidentialGatewayDriver): ) resp.raise_for_status() return self._crypto.decrypt_response(resp.json()) - except Exception: - return None + except (requests.RequestException, ValueError, TypeError, KeyError) as exc: + raise self._request_failed(f"DAL {oid}", exc) from exc - def _fetch_page(self, path: str) -> str | None: + def _fetch_page(self, path: str) -> str: + """The text of *path*; a failed request raises (#15).""" if self._session is None or self._sessionkey is None: raise ConnectionClosedException("Not connected") try: @@ -267,16 +278,34 @@ class ZyxelVMGDriver(ResidentialGatewayDriver): ) resp.raise_for_status() return resp.text - except requests.RequestException: - return None + except requests.RequestException as exc: + raise self._request_failed(f"GET {path}", exc) from exc + + def _request_failed(self, what: str, exc: Exception) -> Exception: + """``ConnectionException`` when the gateway did not answer or refused the session, + ``RuntimeError`` naming *what* for any other failure.""" + detail = f"{what} on {self._base_url} failed: {exc}" + if isinstance(exc, ValueError | TypeError | KeyError): # an answer, but not one we read + return RuntimeError(detail) + status = exc.response.status_code if getattr(exc, "response", None) is not None else None + if status is None or status in _SESSION_REFUSED: + return ConnectionException(detail) + return RuntimeError(detail) + + def _read_dal_or_page( + self, oid: str, page: str, parse_dal: Callable[[Any], _T], parse_page: Callable[[str], _T] + ) -> _T: + """The DAL's answer to *oid*, else the HTML *page*; raises when neither can be read.""" + try: + return parse_dal(json.loads(self._fetch_page(f"cgi-bin/DAL?oid={oid}"))) + except (ConnectionException, RuntimeError, ValueError, TypeError) as exc: + logger.debug("DAL %s not read (%s), reading %s", oid, exc, page) + return parse_page(self._fetch_page(page)) def get_facts(self) -> dict[str, Any]: """Return device facts such as model, serial, OS version, and uptime.""" info = self._device_info or {} - try: - iface_list = list(self.get_interfaces().keys()) - except Exception: - iface_list = [] + iface_list = list(self.get_interfaces().keys()) return { "vendor": self.VENDOR, "model": info.get("ModelName", ""), @@ -520,17 +549,12 @@ class ZyxelVMGDriver(ResidentialGatewayDriver): def get_port_forwards(self) -> list[PortForwardDict]: """Return port forwarding rules from DAL or HTML fallback.""" - html = self._fetch_page("cgi-bin/DAL?oid=NAT_PORTMAP") - if html is not None: - try: - data = json.loads(html) - return self._parse_port_forwards_dal(data) - except (json.JSONDecodeError, TypeError): - pass - html = self._fetch_page("Status.htm") - if html is not None: - return self._parse_port_forwards_html(html) - return [] + return self._read_dal_or_page( + "NAT_PORTMAP", + "Status.htm", + self._parse_port_forwards_dal, + self._parse_port_forwards_html, + ) def _parse_port_forwards_dal(self, data: dict) -> list[PortForwardDict]: forwards: list[PortForwardDict] = [] @@ -577,17 +601,9 @@ class ZyxelVMGDriver(ResidentialGatewayDriver): def get_hosts(self) -> list[HostDict]: """Return DHCP host entries from DAL or HTML fallback.""" - html = self._fetch_page("cgi-bin/DAL?oid=LAN_HOSTS") - if html is not None: - try: - data = json.loads(html) - return self._parse_hosts_dal(data) - except (json.JSONDecodeError, TypeError): - pass - html = self._fetch_page("dhcp.htm") - if html is not None: - return self._parse_hosts_html(html) - return [] + return self._read_dal_or_page( + "LAN_HOSTS", "dhcp.htm", self._parse_hosts_dal, self._parse_hosts_html + ) def _parse_hosts_dal(self, data: dict) -> list[HostDict]: hosts: list[HostDict] = [] @@ -659,17 +675,12 @@ class ZyxelVMGDriver(ResidentialGatewayDriver): def get_wireless_clients(self) -> list[WirelessClientDict]: """Return connected wireless clients from DAL or HTML fallback.""" - html = self._fetch_page("cgi-bin/DAL?oid=WIFI_CLIENTS") - if html is not None: - try: - data = json.loads(html) - return self._parse_wireless_clients_dal(data) - except (json.JSONDecodeError, TypeError): - pass - html = self._fetch_page("wireless.htm") - if html is not None: - return self._parse_wireless_clients_html(html) - return [] + return self._read_dal_or_page( + "WIFI_CLIENTS", + "wireless.htm", + self._parse_wireless_clients_dal, + self._parse_wireless_clients_html, + ) def _parse_wireless_clients_dal(self, data: dict) -> list[WirelessClientDict]: clients: list[WirelessClientDict] = [] @@ -725,17 +736,9 @@ class ZyxelVMGDriver(ResidentialGatewayDriver): def get_ssids(self) -> dict[str, SSIDDict]: """Return WiFi SSID configurations from DAL or HTML fallback.""" - html = self._fetch_page("cgi-bin/DAL?oid=WIFI_SSIDS") - if html is not None: - try: - data = json.loads(html) - return self._parse_ssids_dal(data) - except (json.JSONDecodeError, TypeError): - pass - html = self._fetch_page("wireless.htm") - if html is not None: - return self._parse_ssids_html(html) - return {} + return self._read_dal_or_page( + "WIFI_SSIDS", "wireless.htm", self._parse_ssids_dal, self._parse_ssids_html + ) def _parse_ssids_dal(self, data: dict) -> dict[str, SSIDDict]: ssids: dict[str, SSIDDict] = {} @@ -778,54 +781,55 @@ class ZyxelVMGDriver(ResidentialGatewayDriver): def get_radio_status(self) -> dict[str, RadioStatusDict]: """Return WiFi radio status from DAL or HTML fallback.""" + return self._read_dal_or_page( + "WIFI_RADIO", + "wireless.htm", + self._parse_radio_status_dal, + self._parse_radio_status_html, + ) + + def _parse_radio_status_dal(self, data: dict) -> dict[str, RadioStatusDict]: radios: dict[str, RadioStatusDict] = {} - html = self._fetch_page("cgi-bin/DAL?oid=WIFI_RADIO") - if html is not None: - try: - data = json.loads(html) - entries = data.get("radios", data.get("entries", [])) - if isinstance(entries, dict): - entries = [entries] - for entry in entries if isinstance(entries, list) else []: - name = entry.get("Name", entry.get("name", "")) - channel = int(entry.get("Channel", entry.get("channel", 0)) or 0) - radios[name] = { - "enabled": bool(entry.get("Enabled", entry.get("enabled", True))), - "band": "2.4GHz" if channel <= 14 else "5GHz", - "channel": channel, - "channel_width": int( - entry.get("ChannelWidth", entry.get("channel_width", 0)) or 0 - ), - "tx_power": int(entry.get("TxPower", entry.get("tx_power", 0)) or 0), - "frequency": float(entry.get("Frequency", entry.get("frequency", 0)) or 0), - } - return radios - except (json.JSONDecodeError, TypeError, ValueError): - pass - html = self._fetch_page("wireless.htm") - if html is not None: - for band, pat in [("2.4GHz", r"2\.4[Gg]"), ("5GHz", r"5[Gg]")]: - if re.search(pat, html): - radios[band] = { - "enabled": True, - "band": band, - "channel": 0, - "channel_width": 0, - "tx_power": 0, - "frequency": 0.0, - } + entries = data.get("radios", data.get("entries", [])) + if isinstance(entries, dict): + entries = [entries] + for entry in entries if isinstance(entries, list) else []: + name = entry.get("Name", entry.get("name", "")) + channel = int(entry.get("Channel", entry.get("channel", 0)) or 0) + radios[name] = { + "enabled": bool(entry.get("Enabled", entry.get("enabled", True))), + "band": "2.4GHz" if channel <= 14 else "5GHz", + "channel": channel, + "channel_width": int(entry.get("ChannelWidth", entry.get("channel_width", 0)) or 0), + "tx_power": int(entry.get("TxPower", entry.get("tx_power", 0)) or 0), + "frequency": float(entry.get("Frequency", entry.get("frequency", 0)) or 0), + } + return radios + + def _parse_radio_status_html(self, html: str) -> dict[str, RadioStatusDict]: + radios: dict[str, RadioStatusDict] = {} + for band, pat in [("2.4GHz", r"2\.4[Gg]"), ("5GHz", r"5[Gg]")]: + if re.search(pat, html): + radios[band] = { + "enabled": True, + "band": band, + "channel": 0, + "channel_width": 0, + "tx_power": 0, + "frequency": 0.0, + } return radios def reboot_host(self) -> None: """Restart the gateway (``HostRebootMixin``); raises when it refuses.""" result = self._dal_query("REBOOT", {"Command": "reboot"}) - if result is None or result.get("result") != "ZCFG_SUCCESS": + if result.get("result") != "ZCFG_SUCCESS": raise RuntimeError(f"the gateway refused to reboot: {result}") def restart_wifi(self, band: str = "both") -> None: """Restart the radios of *band* (``2.4G``, ``5G`` or ``both``); raises when refused.""" result = self._dal_query("WIFI_RESTART", {"Band": band}) - if result is None or result.get("result") != "ZCFG_SUCCESS": + if result.get("result") != "ZCFG_SUCCESS": raise RuntimeError(f"the gateway refused to restart Wi-Fi ({band}): {result}") def get_diagnostics(self) -> dict: diff --git a/tests/quality_baseline.json b/tests/quality_baseline.json index 602210b..2206f2a 100644 --- a/tests/quality_baseline.json +++ b/tests/quality_baseline.json @@ -1,8 +1,7 @@ { "coverage_floor": 68.0, "function_complexity": { - "napalm_zyxel/zyxel_driver.py::ZyxelVMGDriver._parse_wireless_clients_dal": 12, - "napalm_zyxel/zyxel_driver.py::ZyxelVMGDriver.get_radio_status": 14 + "napalm_zyxel/zyxel_driver.py::ZyxelVMGDriver._parse_wireless_clients_dal": 12 }, "function_lines": {}, "mypy_relaxed": [ diff --git a/tests/test_failed_reads.py b/tests/test_failed_reads.py new file mode 100644 index 0000000..6876403 --- /dev/null +++ b/tests/test_failed_reads.py @@ -0,0 +1,151 @@ +"""A failed request to the gateway raises; it is not read as "nothing configured" (#15). + +``_dal_query`` and ``_fetch_page`` returned ``None`` for any failure, and the getters +turned that into empty data: a timeout or an expired session read as a gateway with +no hosts, port forwards, SSIDs or Wi-Fi clients. Empty data is now the answer of a +gateway that answered with none; a getter whose DAL request fails still reads the +HTML page, and raises when that fails too. +""" + +from __future__ import annotations + +import json +from typing import Any +from unittest.mock import MagicMock + +import pytest +import requests +from napalm.base.exceptions import ConnectionException + +from napalm_zyxel import ZyxelVMGDriver + +HOSTS_DAL = {"hosts": [{"MACAddress": "AA:BB:CC:DD:EE:01", "IPAddress": "192.168.1.33"}]} +HOSTS_PAGE = "192.168.1.34 aa:bb:cc:dd:ee:02 tablet" + + +def _response(status: int, text: str = "") -> requests.Response: + resp = requests.Response() + resp.status_code = status + resp._content = text.encode() + resp.url = "http://192.168.1.1/" + return resp + + +def _driver(answers: dict[str, requests.Response | Exception]) -> ZyxelVMGDriver: + """A logged-in driver whose session answers each path as told; 404 otherwise.""" + driver = ZyxelVMGDriver("192.168.1.1", "admin", "password") + # NAPALM's __del__ asks is_alive(), which opens a TCP connection: not in a test. + driver.is_alive = lambda: {"is_alive": False} # type: ignore[method-assign] + session = MagicMock(spec=requests.Session) + + def answer(url: str, params: dict[str, Any] | None = None, **_: Any) -> requests.Response: + path = url.removeprefix("http://192.168.1.1:80/") + oid = (params or {}).get("oid") + reply = answers.get(f"{path}?oid={oid}" if oid else path, _response(404)) + if isinstance(reply, Exception): + raise reply + return reply + + session.get.side_effect = answer + session.put.side_effect = answer + driver._session = session + driver._sessionkey = "1" + driver._crypto = MagicMock() + driver._crypto.decrypt_response.side_effect = lambda data: data + driver._device_info = {"ModelName": "VMG4005-B50A"} + return driver + + +# --- _dal_query -------------------------------------------------------------------- + + +def test_dal_query_returns_the_gateways_answer(): + driver = _driver({"cgi-bin/DAL?oid=DIAGNOSTICS": _response(200, '{"result": "ZCFG_SUCCESS"}')}) + assert driver._dal_query("DIAGNOSTICS") == {"result": "ZCFG_SUCCESS"} + + +def test_dal_query_raises_when_the_gateway_does_not_answer(): + driver = _driver({"cgi-bin/DAL?oid=DIAGNOSTICS": requests.ConnectTimeout("timed out")}) + with pytest.raises(ConnectionException, match="timed out"): + driver._dal_query("DIAGNOSTICS") + + +@pytest.mark.parametrize("status", [401, 403]) +def test_dal_query_raises_connection_exception_for_a_refused_session(status): + driver = _driver({"cgi-bin/DAL?oid=DIAGNOSTICS": _response(status)}) + with pytest.raises(ConnectionException, match=str(status)): + driver._dal_query("DIAGNOSTICS") + + +@pytest.mark.parametrize("reply", [_response(500), _response(200, "busy")]) +def test_dal_query_names_the_endpoint_of_any_other_failure(reply): + driver = _driver({"cgi-bin/DAL?oid=DIAGNOSTICS": reply}) + with pytest.raises(RuntimeError, match="DIAGNOSTICS"): + driver._dal_query("DIAGNOSTICS") + + +def test_get_diagnostics_raises_when_the_dal_request_fails(): + driver = _driver({"cgi-bin/DAL?oid=DIAGNOSTICS": _response(500)}) + with pytest.raises(RuntimeError): + driver.get_diagnostics() + + +def test_a_reboot_that_fails_to_reach_the_gateway_raises(): + driver = _driver({"cgi-bin/DAL?oid=REBOOT": requests.ConnectionError("refused")}) + with pytest.raises(ConnectionException): + driver.reboot_host() + + +# --- the getters --------------------------------------------------------------------- + + +@pytest.mark.parametrize( + ("getter", "oid", "page"), + [ + ("get_hosts", "LAN_HOSTS", "dhcp.htm"), + ("get_port_forwards", "NAT_PORTMAP", "Status.htm"), + ("get_wireless_clients", "WIFI_CLIENTS", "wireless.htm"), + ("get_ssids", "WIFI_SSIDS", "wireless.htm"), + ("get_radio_status", "WIFI_RADIO", "wireless.htm"), + ], +) +def test_a_getter_raises_when_neither_the_dal_nor_the_page_can_be_read(getter, oid, page): + driver = _driver( + {f"cgi-bin/DAL?oid={oid}": requests.ReadTimeout("read timed out"), page: _response(500)} + ) + with pytest.raises((ConnectionException, RuntimeError)): + getattr(driver, getter)() + + +def test_get_arp_table_raises_when_the_hosts_cannot_be_read(): + driver = _driver({"cgi-bin/DAL?oid=LAN_HOSTS": _response(500), "dhcp.htm": _response(500)}) + with pytest.raises(RuntimeError): + driver.get_arp_table() + + +def test_a_failed_dal_request_falls_back_to_the_page(): + driver = _driver( + {"cgi-bin/DAL?oid=LAN_HOSTS": _response(500), "dhcp.htm": _response(200, HOSTS_PAGE)} + ) + assert [h["ip"] for h in driver.get_hosts()] == ["192.168.1.34"] + + +def test_the_dal_answer_is_used_when_there_is_one(): + driver = _driver({"cgi-bin/DAL?oid=LAN_HOSTS": _response(200, json.dumps(HOSTS_DAL))}) + assert [h["ip"] for h in driver.get_hosts()] == ["192.168.1.33"] + + +def test_a_gateway_that_lists_no_hosts_has_none(): + driver = _driver({"cgi-bin/DAL?oid=LAN_HOSTS": _response(200, '{"hosts": []}')}) + assert driver.get_hosts() == [] + + +def test_get_facts_lists_the_interfaces(): + assert _driver({}).get_facts()["interface_list"] == ["wan", "lan", "wlan_2_4ghz", "wlan_5ghz"] + + +def test_get_facts_raises_when_the_interfaces_cannot_be_read(): + driver = _driver({}) + driver.get_interfaces = MagicMock(side_effect=RuntimeError("no interfaces")) + with pytest.raises(RuntimeError, match="no interfaces"): + driver.get_facts() -- 2.54.0