From 231def768eda02c66adde8ef54b4c2bbecfb0786 Mon Sep 17 00:00:00 2001 From: Christian Manivong Date: Mon, 2 Nov 2026 08:45:51 +0100 Subject: [PATCH] fix(lldp): keep dotted interface names and read every id type The local interface was the second dotted part of the key, so the neighbours of eth0.1 landed under eth0 with every field missed. The remote port was read from port.ifname or port.id.value, and lldpd prints a port given by MAC or local id as port.mac / port.local, never as id.value, so that port came back empty. lldpd's output now goes through napalm-device-types' parse_lldpctl_keyvalue and its two NAPALM projections, which keep the interface name up to the neighbour's first field and read the ids under whatever type lldpd prints. The detail gains the system description and capabilities on the way. The module is under strict mypy now; the floor on napalm-device-types rises to 4.24.0. Closes #26 --- CHANGELOG.md | 10 +++- napalm_openwrt/lldp_mixin.py | 90 +++++++++--------------------------- pyproject.toml | 3 +- tests/quality_baseline.json | 1 - tests/unit/test_driver.py | 61 ++++++++++++++++++++++++ 5 files changed, 92 insertions(+), 73 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 251a416..e4fee89 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,7 +15,8 @@ recorded here; their history is the git log. to do on every poll (#8). Needs napalm-device-types with `LldpAgentMixin`. ### Changed -- The floor on napalm-device-types is 4.23.0, the first release with what this driver uses. +- The floor on napalm-device-types is 4.24.0, the first release with what this driver + uses (its shared `lldpctl` parser). - Python 3.12 is the floor (`requires-python = ">=3.12"`): netOrk runs every driver on 3.12, so 3.10 and 3.11 are no longer tested (NAPALM/driver-standard#6). - The floor on napalm is 5.1: older releases import `pkg_resources`, which a Python @@ -27,6 +28,13 @@ recorded here; their history is the git log. `manage_service("lldpd", "enable")` and `manage_service("lldpd", "start")` (#8). ### Fixed +- `get_lldp_neighbors()` and `get_lldp_neighbors_detail()` keep an interface name with + a dot whole: the neighbours of a VLAN interface such as `eth0.1` used to come back + under `eth0` with every field empty (#26). A neighbour that names its port by MAC + address or a local id is reported with that port instead of an empty one, and a + chassis named by a local id or an address with that id. The detail now also + carries the neighbour's system description and capabilities, which were always + empty. lldpd's output is parsed by napalm-device-types' shared parser. - `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": neither `ip neigh` nor `/proc/net/arp` has an age (NetOrk/netork#1327). diff --git a/napalm_openwrt/lldp_mixin.py b/napalm_openwrt/lldp_mixin.py index 86da3f1..aec684f 100644 --- a/napalm_openwrt/lldp_mixin.py +++ b/napalm_openwrt/lldp_mixin.py @@ -12,40 +12,24 @@ from __future__ import annotations -from typing import Any +from typing import TYPE_CHECKING -#: The keys a neighbour opens with in ``lldpctl -f keyvalue``: an optional -#: ``alias``, then ``via`` (lldpd's ``display_interface``). -_NEIGHBOUR_START = ("alias", "via") +from napalm.base.models import LLDPNeighborDetailDict, LLDPNeighborDict +from napalm_device_types import ( + LldpNeighborRow, + lldp_neighbors, + lldp_neighbors_detail, + parse_lldpctl_keyvalue, +) - -def _keyvalue_neighbours(output: str) -> list[tuple[str, dict[str, str]]]: - """``lldpctl -f keyvalue`` as ``(local interface, {subkey: value})``, one per neighbour. - - Every neighbour on a port prints the same keys, so a port is no key: a - neighbour ends where the next one opens. A key may repeat inside one - neighbour (``chassis.mgmt-ip``, one per address); the last value stays. - """ - neighbours: list[tuple[str, dict[str, str]]] = [] - for line in output.splitlines(): - key, sep, value = line.strip().partition("=") - parts = key.split(".") - # parts: ['lldp', '', , , ...] - if not sep or len(parts) < 3 or parts[0] != "lldp": - continue - iface, subkey = parts[1], ".".join(parts[2:]) - current = neighbours[-1][1] if neighbours and neighbours[-1][0] == iface else None - if current is None or (subkey in _NEIGHBOUR_START and set(current) - {"alias"}): - current = {} - neighbours.append((iface, current)) - current[subkey] = value - return neighbours +#: lldpd's neighbours, parsed by napalm-device-types' ``parse_lldpctl_keyvalue``. +_LLDPCTL_COMMAND = "lldpctl -f keyvalue" class OpenWrtLLDPMixin: """Mixin providing LLDP NAPALM getters.""" - def get_lldp_neighbors(self) -> dict[str, list[dict[str, Any]]]: + def get_lldp_neighbors(self) -> dict[str, list[LLDPNeighborDict]]: """Return LLDP neighbors (requires ``lldpd`` installed and running on the device). Uses ``lldpctl -f keyvalue`` output:: @@ -53,55 +37,23 @@ class OpenWrtLLDPMixin: lldp.eth0.port.ifname=eth1 lldp.eth0.chassis.name=router-core """ - neighbors: dict[str, list[dict[str, Any]]] = {} - for row in self._get_lldp_table(): - neighbors.setdefault(row["local_port"], []).append( - {"hostname": row["system_name"], "port": row["port_id"]} - ) - return neighbors + return lldp_neighbors(self._get_lldp_table()) - def _get_lldp_table(self) -> list[dict[str, Any]]: - """Parse ``lldpctl -f keyvalue`` into a list of row dicts. + def _get_lldp_table(self) -> list[LldpNeighborRow]: + """``lldpctl -f keyvalue`` as one row per neighbour. Reads only: lldpd is neither started nor reconfigured here. Installing, starting and configuring it are the caller's (``ensure_package``, ``manage_service``). """ - output = self._send_command("lldpctl -f keyvalue") - rows: list[dict[str, Any]] = [] + return parse_lldpctl_keyvalue(self._send_command(_LLDPCTL_COMMAND)) - for iface, data in _keyvalue_neighbours(output): - rows.append( - { - "local_port": iface, - "remote_chassis_id": data.get("chassis.mac", data.get("chassis.id.value", "")), - "port_id": data.get("port.ifname", data.get("port.id.value", "")), - "mgmt_address": data.get("chassis.mgmt-ip", ""), - "port_description": data.get("port.descr", ""), - "system_name": data.get("chassis.name", ""), - } - ) - - return rows - - def get_lldp_neighbors_detail(self, interface: str = "") -> dict[str, list[dict[str, Any]]]: + def get_lldp_neighbors_detail( + self, interface: str = "" + ) -> dict[str, list[LLDPNeighborDetailDict]]: """Return detailed LLDP neighbor info.""" - details: dict[str, list[dict[str, Any]]] = {} + return lldp_neighbors_detail(self._get_lldp_table(), interface) - for row in self._get_lldp_table(): - if interface and row["local_port"] != interface: - continue - details.setdefault(row["local_port"], []).append( - { - "parent_interface": "", - "remote_port": row["port_id"], - "remote_port_description": row["port_description"], - "remote_chassis_id": row["remote_chassis_id"], - "remote_system_name": row["system_name"], - "remote_system_description": "", - "remote_system_capab": [], - "remote_system_enable_capab": [], - } - ) + if TYPE_CHECKING: # pragma: no cover - the driver's - return details + def _send_command(self, command: str | list[str]) -> str: ... diff --git a/pyproject.toml b/pyproject.toml index 70ad6df..c9e6c5a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -21,7 +21,7 @@ classifiers = [ ] dependencies = [ "napalm>=5.1", # older releases import pkg_resources, which a 3.12 venv lacks - "napalm_device_types>=4.23.0", + "napalm_device_types>=4.24.0", "netmiko>=4.0.0", "paramiko>=5.0.0", # CVE-2026-44405 "netaddr>=0.7.19", # IPAddress; below it the package has none (CI lowest job) @@ -71,7 +71,6 @@ ignore_missing_imports = true module = [ "napalm_openwrt.config_mixin", "napalm_openwrt.interfaces_mixin", - "napalm_openwrt.lldp_mixin", "napalm_openwrt.openwrt", "napalm_openwrt.packages_mixin", "napalm_openwrt.routing_mixin", diff --git a/tests/quality_baseline.json b/tests/quality_baseline.json index 0cbab18..fc2dcf8 100644 --- a/tests/quality_baseline.json +++ b/tests/quality_baseline.json @@ -40,7 +40,6 @@ "mypy_relaxed": [ "napalm_openwrt.config_mixin", "napalm_openwrt.interfaces_mixin", - "napalm_openwrt.lldp_mixin", "napalm_openwrt.openwrt", "napalm_openwrt.packages_mixin", "napalm_openwrt.routing_mixin", diff --git a/tests/unit/test_driver.py b/tests/unit/test_driver.py index 8b694c6..6da53ba 100644 --- a/tests/unit/test_driver.py +++ b/tests/unit/test_driver.py @@ -421,6 +421,67 @@ class TestLldpSeveralNeighboursOnOnePort: assert len(driver.get_lldp_neighbors_detail("lan1")["lan1"]) == 2 +# A swconfig VLAN interface (``eth0.1``) with a neighbour that names its port by +# MAC, and a switch on ``eth1`` that names itself and its port by local ids. +# Laid out the way lldpd's keyvalue writer prints them (src/client/display.c): +# an id is printed under its type, never as ``id.value``. Not recorded from a device. +LLDPCTL_KV_DOTTED_AND_ID_TYPES = """\ +lldp.eth0.1.via=LLDP +lldp.eth0.1.rid=1 +lldp.eth0.1.chassis.mac=00:11:22:33:44:01 +lldp.eth0.1.chassis.name=desk-phone +lldp.eth0.1.chassis.descr=SIP phone +lldp.eth0.1.chassis.Tel.enabled=on +lldp.eth0.1.port.mac=00:11:22:33:44:01 +lldp.eth0.1.port.descr=WAN +lldp.eth1.via=LLDP +lldp.eth1.rid=2 +lldp.eth1.chassis.local=access-sw-01 +lldp.eth1.chassis.name=access-sw +lldp.eth1.chassis.Bridge.enabled=on +lldp.eth1.chassis.Router.enabled=off +lldp.eth1.port.local=gi1/0/7 +""" + + +class TestLldpDottedInterfaceAndPortIds: + """``eth0.1`` keeps its name, and a port id given as MAC or local id is read (#26).""" + + def test_a_dotted_interface_keeps_its_name(self, driver): + driver._send_command = lambda cmd, **kw: LLDPCTL_KV_DOTTED_AND_ID_TYPES + + result = driver.get_lldp_neighbors() + + assert sorted(result) == ["eth0.1", "eth1"] + assert result["eth0.1"][0]["hostname"] == "desk-phone" + + def test_a_port_given_by_mac_or_local_id_is_read(self, driver): + driver._send_command = lambda cmd, **kw: LLDPCTL_KV_DOTTED_AND_ID_TYPES + + result = driver.get_lldp_neighbors() + + assert result["eth0.1"][0]["port"] == "00:11:22:33:44:01" + assert result["eth1"][0]["port"] == "gi1/0/7" + + def test_a_chassis_given_by_a_local_id_is_read(self, driver): + driver._send_command = lambda cmd, **kw: LLDPCTL_KV_DOTTED_AND_ID_TYPES + + switch = driver.get_lldp_neighbors_detail("eth1")["eth1"][0] + + assert switch["remote_chassis_id"] == "access-sw-01" + + def test_the_detail_carries_description_and_capabilities(self, driver): + driver._send_command = lambda cmd, **kw: LLDPCTL_KV_DOTTED_AND_ID_TYPES + + detail = driver.get_lldp_neighbors_detail() + + phone = detail["eth0.1"][0] + assert phone["remote_port_description"] == "WAN" + assert phone["remote_system_description"] == "SIP phone" + assert phone["remote_system_enable_capab"] == ["telephone"] + assert detail["eth1"][0]["remote_system_capab"] == ["bridge", "router"] + + BRIDGE_VLAN_SHOW = """\ port vlan-id eth0 1 PVID Egress Untagged