fix(dal): raise on a failed request instead of reading it as empty #16

Merged
christianmanivong merged 1 commits from fix/bugs-2026-11-02b into main 2026-11-02 09:40:44 +00:00
4 changed files with 257 additions and 94 deletions

No files matched your search

+9
View File
@@ -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).
+96 -92
View File
@@ -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:
+1 -2
View File
@@ -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": [
+151
View File
@@ -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, "<html>busy</html>")])
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()