python-netgear-switch-library 0.0.post290__tar.gz → 0.0.post294__tar.gz

{python_netgear_switch_library-0.0.post290 → python_netgear_switch_library-0.0.post294}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-netgear-switch-library
-Version: 0.0.post290
+Version: 0.0.post294
 Summary: Python library and CLI to query and control Netgear switches over SNMP, NSDP and HTTP.
 Author-email: Tim Ansell <me@mith.ro>
 License-Expression: Apache-2.0

{python_netgear_switch_library-0.0.post290 → python_netgear_switch_library-0.0.post294}/src/netgear_switch/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.0.post290'
-__version_tuple__ = version_tuple = (0, 0, 'post290')
+__version__ = version = '0.0.post294'
+__version_tuple__ = version_tuple = (0, 0, 'post294')
 
 __commit_id__ = commit_id = None

{python_netgear_switch_library-0.0.post290 → python_netgear_switch_library-0.0.post294}/src/netgear_switch/snmp_write.py

@@ -109,6 +109,22 @@ class SnmpWriter:
     def _vlan(self, vlan: int) -> VLANInfo | None:
         return next((v for v in self._reader.get_vlans() if v.vlan_id == vlan), None)
 
+    def _raw_bitmap(self, base_oid: str, vlan: int) -> bytes | None:
+        """The device's own PortList octets for ``vlan``, width intact.
+
+        VLANInfo carries decoded port sets, so re-encoding from it would size
+        the bitmap to the highest port in use rather than to the width the
+        device actually uses. Netgear switches report a PortList covering LAG
+        and CPU pseudo-ports: measured live, 131 bytes on a 28-port M4300-24X
+        and 79 bytes on a GSM7252PS. Returns None if the device did not report
+        this VLAN as octets, so callers can fall back.
+        """
+        suffix = f".{vlan}"
+        for row in self.client.walk(base_oid):
+            if row.oid.endswith(suffix) and isinstance(row.value, bytes):
+                return row.value
+        return None
+
     def set_poe(self, port: int, on: bool, *, force: bool = False) -> None:
         if not on:
             self._guard(port, force)  # turning PoE off is disruptive
@@ -253,11 +269,17 @@ class SnmpWriter:
             # Precondition failure: no SET has been attempted, so this is NOT a
             # verification divergence (review item 9).
             raise SnmpError(f"VLAN {vlan} does not exist")
+        # Feed set_port_bit the device's OWN bitmaps so it preserves their exact
+        # wire width (that is what it is for); fall back to a re-encode of the
+        # decoded sets only if the device did not report octets.
+        raw_egress = self._raw_bitmap(oids.DOT1Q_VLAN_STATIC_EGRESS, vlan)
+        raw_untagged = self._raw_bitmap(oids.DOT1Q_VLAN_STATIC_UNTAGGED, vlan)
         new_egress, new_untagged = membership_bitmaps(
-            mode=mode,
-            port=port,
-            egress=encode_port_bitmap(before.member_ports),
-            untagged=encode_port_bitmap(before.untagged_ports),
+            mode=mode, port=port,
+            egress=(raw_egress if raw_egress is not None
+                    else encode_port_bitmap(before.member_ports)),
+            untagged=(raw_untagged if raw_untagged is not None
+                      else encode_port_bitmap(before.untagged_ports)),
             width_bytes=vlan_bitmap_width(self.model),
         )
         self.client.set_many(
@@ -426,6 +448,14 @@ class AsyncSnmpWriter:
         vlans = await self._reader.get_vlans()
         return next((v for v in vlans if v.vlan_id == vlan), None)
 
+    async def _raw_bitmap(self, base_oid: str, vlan: int) -> bytes | None:
+        """Async twin of ``SnmpWriter._raw_bitmap`` -- see it for why."""
+        suffix = f".{vlan}"
+        for row in await self.client.walk(base_oid):
+            if row.oid.endswith(suffix) and isinstance(row.value, bytes):
+                return row.value
+        return None
+
     async def set_poe(self, port: int, on: bool, *, force: bool = False) -> None:
         if not on:
             self._guard(port, force)
@@ -564,11 +594,15 @@ class AsyncSnmpWriter:
         if before is None:
             # Precondition failure (review item 9): no SET attempted.
             raise SnmpError(f"VLAN {vlan} does not exist")
+        # Preserve the device's own bitmap width -- see SnmpWriter._raw_bitmap.
+        raw_egress = await self._raw_bitmap(oids.DOT1Q_VLAN_STATIC_EGRESS, vlan)
+        raw_untagged = await self._raw_bitmap(oids.DOT1Q_VLAN_STATIC_UNTAGGED, vlan)
         new_egress, new_untagged = membership_bitmaps(
-            mode=mode,
-            port=port,
-            egress=encode_port_bitmap(before.member_ports),
-            untagged=encode_port_bitmap(before.untagged_ports),
+            mode=mode, port=port,
+            egress=(raw_egress if raw_egress is not None
+                    else encode_port_bitmap(before.member_ports)),
+            untagged=(raw_untagged if raw_untagged is not None
+                      else encode_port_bitmap(before.untagged_ports)),
             width_bytes=vlan_bitmap_width(self.model),
         )
         await self.client.set_many(

{python_netgear_switch_library-0.0.post290 → python_netgear_switch_library-0.0.post294}/src/netgear_switch/virtual/seed.py

@@ -1187,6 +1187,9 @@ def seed_gsm7252ps() -> VirtualSwitchState:
         vlans=vlans,
         pvids=pvids,
         poe=poe,
+        # Real fixed Q-BRIDGE PortList width, measured LIVE (read-only) on this
+        # switch @10.1.5.22: dot1qVlanStaticEgressPorts is 79 bytes wide.
+        vlan_portlist_width=79,
         sensors=sensors,
         http_sensors=http_sensors,
         macs=macs,
@@ -2170,6 +2173,9 @@ def seed_m4300_24x() -> VirtualSwitchState:
         ports=ports,
         vlans=vlans,
         pvids=pvids,
+        # Real fixed Q-BRIDGE PortList width, measured LIVE (read-only) on the
+        # M4300 @10.1.5.13: dot1qVlanStaticEgressPorts is 131 bytes wide.
+        vlan_portlist_width=131,
         poe={},  # VERIFIED: real capture's poe=[] -- this model has NO PoE.
         sensors=sensors,
         macs=macs,
@@ -2339,6 +2345,9 @@ def seed_m4300_16x() -> VirtualSwitchState:
         ports=ports,
         vlans=vlans,
         pvids=pvids,
+        # Real fixed Q-BRIDGE PortList width, measured LIVE (read-only) on this
+        # switch @10.1.5.20: dot1qVlanStaticEgressPorts is 131 bytes wide.
+        vlan_portlist_width=131,
         poe=poe,  # VERIFIED: real capture -- all 16 ports PoE-capable.
         sensors=sensors,
         macs=macs,

{python_netgear_switch_library-0.0.post290 → python_netgear_switch_library-0.0.post294}/src/netgear_switch/virtual/state.py

@@ -263,6 +263,20 @@ class VirtualSwitchState:
     # 6-byte encoding; only a seed with hardware evidence of this quirk
     # should set it True.
     dot1d_base_mac_ascii: bool = False
+    # Fixed Q-BRIDGE PortList byte-width the SNMP agent reports for
+    # dot1qVlanStaticEgressPorts / dot1qVlanStaticUntaggedPorts. A real switch
+    # emits a CONSTANT-width bitmap covering every port it knows -- physical
+    # ports PLUS the LAG/CPU pseudo-ports far above the physical count -- so the
+    # width does NOT track the highest member. Measured LIVE (read-only,
+    # community "public"): GSM7252PS @10.1.5.22 = 79 bytes (highest set byte 60
+    # => LAG ~port 481); M4300 @10.1.5.13 = 131 bytes (highest set byte 112 =>
+    # ~port 897). None = unmeasured: oid_map() falls back to
+    # vlan_bitmap_width(model), the physical-port-only width. Seeding the REAL
+    # width is what lets the mock catch the historical writer bug (issue #3):
+    # the buggy writer re-encoded the decoded member set at max(8, port_count/8)
+    # rather than preserving the device width, so it sent a SET narrower than
+    # this -- which a stricter Q-BRIDGE agent rejects outright.
+    vlan_portlist_width: int | None = None
 
     @property
     def sysinfo_sensors(self) -> list[SensorSim]:
@@ -290,7 +304,13 @@ class VirtualSwitchState:
         # vendor-column projections below are skipped, matching a real agent
         # that answers noSuchObject for the whole 4526 tree.
         v = oids.vendor_oids(model) if oids.has_vendor_oids(model) else None
-        vlan_width = vlan_bitmap_width(model)
+        # Prefer the device's REAL fixed PortList width (live-measured, seeded on
+        # vlan_portlist_width) so the mock is an INDEPENDENT source of truth for
+        # the wire width -- not a re-derivation of the same vlan_bitmap_width()
+        # formula the writer uses (that shared assumption is exactly why the mock
+        # never caught issue #3). Falls back to the physical-port-only width when
+        # a model's real width hasn't been measured.
+        vlan_width = self.vlan_portlist_width or vlan_bitmap_width(model)
         m: dict[str, tuple[str, str]] = {}
 
         # dot1dBaseBridgeAddress (BRIDGE-MIB scalar): the switch's own base
@@ -514,7 +534,15 @@ class VirtualSwitchState:
             self.pvids[port] = int(value)
             return
 
-        # dot1qVlanStaticEgressPorts.<vid>
+        # dot1qVlanStaticEgressPorts.<vid> -- decode the incoming PortList and
+        # REPLACE the member set, exactly as a real Q-BRIDGE agent does. A
+        # too-narrow PortList (the historical writer bug) is faithfully
+        # truncating here: every member beyond the incoming byte width is
+        # silently dropped -- the exact silent VLAN corruption the GSM7252PS
+        # exhibits on hardware for an 8-byte SET against its 79-byte PortList.
+        # tests/virtual/test_snmp_write_face.py proves both the corruption (a
+        # narrow SET drops the LAG/CPU members) and that the width-preserving
+        # writer keeps them.
         vid = _tail(oids.DOT1Q_VLAN_STATIC_EGRESS)
         if vid is not None and vid in self.vlans:
             from ..protocols.snmp.parse import decode_port_bitmap
@@ -522,7 +550,7 @@ class VirtualSwitchState:
             self.vlans[vid].member = set(decode_port_bitmap(_as_bytes(value)))
             return
 
-        # dot1qVlanStaticUntaggedPorts.<vid>
+        # dot1qVlanStaticUntaggedPorts.<vid>  (same truncation semantics)
         vid = _tail(oids.DOT1Q_VLAN_STATIC_UNTAGGED)
         if vid is not None and vid in self.vlans:
             from ..protocols.snmp.parse import decode_port_bitmap

{python_netgear_switch_library-0.0.post290 → python_netgear_switch_library-0.0.post294}/tests/test_snmp_write.py

@@ -295,6 +295,100 @@ def test_set_vlan_membership_catches_dropped_untagged_write():
     assert "untagged" in str(exc.value)
 
 
+def test_set_vlan_membership_preserves_device_bitmap_width():
+    """A SET must be as wide as the PortList the device actually reports.
+
+    Netgear switches report a PortList far wider than the model's physical
+    port count -- it covers LAG and CPU pseudo-ports too. Measured live:
+    131 bytes on an M4300-24X (port_count 28) and on an M4300-16X, 79 bytes
+    on a GSM7252PS. Re-deriving the width from the decoded port set instead of
+    the device's own bitmap makes the SET a different wire length than the
+    device uses.
+    """
+    wide = bytes(131)  # the device's PortList width, no ports set yet
+    tables = _vlan_tables()
+    tables[oids.DOT1Q_VLAN_STATIC_EGRESS] = [
+        SnmpRow(f"{oids.DOT1Q_VLAN_STATIC_EGRESS}.90", wide, "Hex-STRING")
+    ]
+    tables[oids.DOT1Q_VLAN_STATIC_UNTAGGED] = [
+        SnmpRow(f"{oids.DOT1Q_VLAN_STATIC_UNTAGGED}.90", wide, "Hex-STRING")
+    ]
+    client = ApplyingVlanClient(tables)
+    w = SnmpWriter(client, get_model("m4300-24x"))
+    w.set_vlan_membership(90, 7, VlanMode.UNTAGGED, force=True)
+
+    egress_set = next(
+        vb for vb in client.sets
+        if vb.oid.startswith(oids.DOT1Q_VLAN_STATIC_EGRESS)
+    )
+    untagged_set = next(
+        vb for vb in client.sets
+        if vb.oid.startswith(oids.DOT1Q_VLAN_STATIC_UNTAGGED)
+    )
+    assert len(egress_set.value) == len(wide)
+    assert len(untagged_set.value) == len(wide)
+    assert 7 in decode_port_bitmap(egress_set.value)
+    assert 7 in decode_port_bitmap(untagged_set.value)
+
+
+def _bitmap_bytes(value: object) -> bytes:
+    """Coerce an oid_map() PortList value (bytes or latin-1 wire str) to bytes."""
+    if isinstance(value, (bytes, bytearray)):
+        return bytes(value)
+    return str(value).encode("latin-1")
+
+
+def test_set_vlan_membership_preserves_mock_emitted_portlist_width():
+    """End-to-end with the VIRTUAL MOCK as the device -- the regression that
+    ties the mock's independent width to the writer preserving it (issue #3).
+
+    The seeded gsm7252ps mock now emits the device's REAL fixed PortList width
+    (79 bytes, live-measured @10.1.5.22), not the physical-port-only
+    vlan_bitmap_width() the writer historically re-derived. A SET must go out at
+    that full 79-byte width. The OLD writer -- which re-encoded the decoded
+    member set at max(8, port_count/8), growing only to cover the highest
+    member -- would emit at most ceil(highest_member/8) bytes (<= 61 here),
+    NEVER 79, so this test fails against it. It is green now precisely because
+    _raw_bitmap() preserves the device's own bitmap width.
+    """
+    from netgear_switch.virtual.seed import seed_gsm7252ps
+
+    state = seed_gsm7252ps()
+    m = state.oid_map()
+    vid = min(state.vlans)  # a real seeded VLAN (VLAN 1)
+    egress = _bitmap_bytes(m[f"{oids.DOT1Q_VLAN_STATIC_EGRESS}.{vid}"][1])
+    untagged = _bitmap_bytes(m[f"{oids.DOT1Q_VLAN_STATIC_UNTAGGED}.{vid}"][1])
+    # The mock is faithful to the live measurement: a fixed 79-byte PortList.
+    assert len(egress) == 79
+
+    members = set(decode_port_bitmap(egress))
+    unused = next(p for p in range(1, 49) if p not in members)  # a free phys port
+
+    tables = {
+        oids.DOT1Q_VLAN_STATIC_NAME: [
+            SnmpRow(f"{oids.DOT1Q_VLAN_STATIC_NAME}.{vid}", "seeded", "STRING")
+        ],
+        oids.DOT1Q_VLAN_STATIC_EGRESS: [
+            SnmpRow(f"{oids.DOT1Q_VLAN_STATIC_EGRESS}.{vid}", egress, "Hex-STRING")
+        ],
+        oids.DOT1Q_VLAN_STATIC_UNTAGGED: [
+            SnmpRow(f"{oids.DOT1Q_VLAN_STATIC_UNTAGGED}.{vid}", untagged, "Hex-STRING")
+        ],
+    }
+    client = ApplyingVlanClient(tables)
+    w = SnmpWriter(client, get_model("gsm7252ps"))
+    w.set_vlan_membership(vid, unused, VlanMode.TAGGED, force=True)
+
+    egress_set = next(
+        vb for vb in client.sets if vb.oid.startswith(oids.DOT1Q_VLAN_STATIC_EGRESS)
+    )
+    # Width preserved end-to-end, and no member lost while adding the new port.
+    assert len(egress_set.value) == 79
+    got = set(decode_port_bitmap(egress_set.value))
+    assert unused in got
+    assert members <= got
+
+
 def test_set_vlan_membership_missing_vlan_is_precondition_not_verify_error():
     client = ApplyingVlanClient({})  # no VLAN 90 present
     w = SnmpWriter(client, get_model("gsm7252ps"))

{python_netgear_switch_library-0.0.post290 → python_netgear_switch_library-0.0.post294}/tests/virtual/test_state_seed.py

@@ -230,3 +230,46 @@ def test_seed_gsm7252ps_iot_vlan_90_matches_capture():
         assert port in state.vlans[90].untagged
     assert dict(capture["pvids"])[1] == state.pvids[1] == 90
     assert dict(capture["pvids"])[2] == state.pvids[2] == 90
+
+
+def test_seed_emits_real_fixed_vlan_portlist_width():
+    """Every VLAN's egress/untagged PortList is the device's REAL fixed byte
+    width, LIVE-measured read-only on each switch, NOT the physical-port-only
+    vlan_bitmap_width(). This is what makes the mock an independent source of
+    truth for the wire width (github issue #3): the historical writer bug --
+    re-encoding the decoded member set at max(8, port_count/8) -- sent a SET
+    narrower than this, which the mock now models faithfully so a round-trip
+    test can catch it.
+
+    Widths: gsm7252ps=79B @10.1.5.22, m4300-24x=131B @10.1.5.13,
+    m4300-16x=131B @10.1.5.20 (dot1qVlanStaticEgressPorts, community public).
+    """
+    from netgear_switch.virtual.seed import (
+        seed_gsm7252ps,
+        seed_m4300_16x,
+        seed_m4300_24x,
+    )
+
+    for seed, expected in (
+        (seed_gsm7252ps, 79),
+        (seed_m4300_24x, 131),
+        (seed_m4300_16x, 131),
+    ):
+        state = seed()
+        m = state.oid_map()
+        egress = [
+            v for k, v in m.items() if k.startswith(oids.DOT1Q_VLAN_STATIC_EGRESS + ".")
+        ]
+        untagged = [
+            v
+            for k, v in m.items()
+            if k.startswith(oids.DOT1Q_VLAN_STATIC_UNTAGGED + ".")
+        ]
+        assert egress, f"{seed.__name__}: no VLAN egress rows emitted"
+        for _typ, value in egress + untagged:
+            raw = value if isinstance(value, (bytes, bytearray)) else value.encode(
+                "latin-1"
+            )
+            assert len(raw) == expected, (
+                f"{seed.__name__}: PortList {len(raw)}B, expected fixed {expected}B"
+            )

{python_netgear_switch_library-0.0.post290 → python_netgear_switch_library-0.0.post294}/tests/virtual/test_virtual_snmp_face.py

@@ -241,9 +241,13 @@ def test_type_token_round_trips_through_pysnmp_client():
         rows = asyncio.run(client.get([oid]))
         assert rows == [SnmpRow(oid, sw.state.mgmt.address, "IpAddress")]
 
-        # OCTETSTR-as-bytes bitmap: dot1qVlanStaticEgressPorts.90
+        # OCTETSTR-as-bytes bitmap: dot1qVlanStaticEgressPorts.90 -- the mock
+        # emits the device's REAL fixed PortList width (79 B, live-measured), so
+        # derive the expected at that seeded width, still straight from the seed.
         oid = f"{oids.DOT1Q_VLAN_STATIC_EGRESS}.90"
-        expected_bitmap = encode_port_bitmap(vlan90.member).encode("latin-1")
+        expected_bitmap = encode_port_bitmap(
+            vlan90.member, width_bytes=sw.state.vlan_portlist_width
+        ).encode("latin-1")
         rows = asyncio.run(client.get([oid]))
         assert rows == [SnmpRow(oid, expected_bitmap, "Hex-STRING")]
 
@@ -401,7 +405,12 @@ def test_ip_address_and_bitmap_round_trip_through_netsnmp_cli_client():
         assert rows == [SnmpRow(oid, sw.state.mgmt.address, "IpAddress")]
 
         oid = f"{oids.DOT1Q_VLAN_STATIC_EGRESS}.90"
-        expected_bitmap = encode_port_bitmap(vlan90.member).encode("latin-1")
+        # The mock emits the device's REAL fixed PortList width (79 B on the
+        # gsm7252ps, live-measured), so derive the expected bitmap at that same
+        # seeded width -- still straight from the seed, never hardcoded.
+        expected_bitmap = encode_port_bitmap(
+            vlan90.member, width_bytes=sw.state.vlan_portlist_width
+        ).encode("latin-1")
         rows = client.get([oid])
         assert rows == [SnmpRow(oid, expected_bitmap, "Hex-STRING")]
     finally: