python-netgear-switch-library 0.0.post345__tar.gz → 0.0.post347__tar.gz

{python_netgear_switch_library-0.0.post345 → python_netgear_switch_library-0.0.post347}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-netgear-switch-library
-Version: 0.0.post345
+Version: 0.0.post347
 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.post345 → python_netgear_switch_library-0.0.post347}/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.post345'
-__version_tuple__ = version_tuple = (0, 0, 'post345')
+__version__ = version = '0.0.post347'
+__version_tuple__ = version_tuple = (0, 0, 'post347')
 
 __commit_id__ = commit_id = None

{python_netgear_switch_library-0.0.post345 → python_netgear_switch_library-0.0.post347}/src/netgear_switch/aio_api.py

@@ -95,6 +95,8 @@ if TYPE_CHECKING:
         PortStats,
         PortStatus,
         Sensor,
+        ServiceStatus,
+        SwitchUser,
         SyslogConfig,
         VLANInfo,
         VlanMode,
@@ -452,6 +454,20 @@ class AsyncSwitch:
         """Async twin of ``SyncSwitch.get_syslog`` -- see there."""
         return await self._read(lambda r: r.get_syslog(), backend)
 
+    async def get_users(self, *, backend: Backend | None = None) -> list[SwitchUser]:
+        """Async twin of ``SyncSwitch.get_users``.
+
+        AsyncSwitch has no CLI backend, so this refuses on every model -- the
+        same honest refusal every async CLI read gives.
+        """
+        return await self._read(lambda r: r.get_users(), backend)
+
+    async def get_services(
+        self, *, backend: Backend | None = None
+    ) -> list[ServiceStatus]:
+        """Async twin of ``SyncSwitch.get_services`` -- CLI only, see there."""
+        return await self._read(lambda r: r.get_services(), backend)
+
     async def get_hostname(self, *, backend: Backend | None = None) -> str:
         """Async twin of ``SyncSwitch.get_hostname`` -- see there."""
         return await self._read(lambda r: r.get_hostname(), backend)

{python_netgear_switch_library-0.0.post345 → python_netgear_switch_library-0.0.post347}/src/netgear_switch/capabilities.py

@@ -114,6 +114,28 @@ READ_OPERATIONS: tuple[Operation, ...] = (
     Operation("get_sensors", OperationKind.READ, "Fan/PSU/temperature sensors"),
     Operation("get_mgmt_ip", OperationKind.READ, "Management IP configuration"),
     Operation("get_hostname", OperationKind.READ, "The switch's host name"),
+    Operation(
+        "get_users",
+        OperationKind.READ,
+        "Local login accounts and their access level",
+        # CLI only, deliberately. The S3300's vendor SNMP user table holds ONE
+        # account where its own CLI lists two, so the two backends do not report
+        # the same set; claiming both serve this would assert an equivalence the
+        # hardware contradicts. Restricting it to the CLI makes no cross-backend
+        # claim at all, and leaves the SNMP question open rather than answered
+        # wrongly.
+        backends=_CLI_BACKENDS,
+    ),
+    Operation(
+        "get_services",
+        OperationKind.READ,
+        "Which management services (http/https/telnet/ssh) are enabled",
+        # CLI only so far: `show ip http`, `show telnetcon` and `show ip ssh`
+        # are measured, and the SNMP/HTTP/NSDP equivalents are unlocated rather
+        # than absent. The four models with no CLI backend therefore have no
+        # route to this yet, which the support table now shows as a hole.
+        backends=_CLI_BACKENDS,
+    ),
     Operation(
         "get_syslog",
         OperationKind.READ,
@@ -153,16 +175,21 @@ WRITE_OPERATIONS: tuple[Operation, ...] = (
         "set_hostname",
         OperationKind.WRITE,
         "Set the switch's host name",
-        # SNMP (sysName, confirmed writable on all five reachable switches) and
-        # the FASTPATH CLI (`hostname`) are what the library writes today.
+        # SNMP (sysName), NSDP (tag 0x0003) and the FASTPATH CLI (`hostname`),
+        # each confirmed writable against real hardware:
         #
-        # This restriction makes a REAL GAP visible rather than hiding it: the
-        # Plus models have neither backend, so this library currently cannot
-        # rename a gs110emx, gs105pe or gs305ep at all. Both routes exist on the
-        # devices -- NSDP carries a writable HOSTNAME tag and two web UIs expose
-        # a switch_name field -- so this is unbuilt work, not a device limit,
-        # and the support table should show the hole until it is filled.
-        backends=frozenset({Backend.SNMP}) | _CLI_BACKENDS,
+        #   SNMP  all five reachable switches accepted a SET of the value they
+        #         already held -- a zero-impact writability probe
+        #   NSDP  live round trip on gs110emx3 (10.1.5.27): recorded the prior
+        #         name, wrote a throwaway, read it back, restored, re-read
+        #   CLI   round-trips on all four CLI models
+        #
+        # That closes the Plus-model hole this restriction used to expose: every
+        # registered model now has at least one backend that can rename it. HTTP
+        # is still absent -- two web UIs carry a switch_name field but the write
+        # is unbuilt -- so the restriction stays, and states what the library
+        # serves rather than what the devices can do.
+        backends=frozenset({Backend.SNMP, Backend.NSDP}) | _CLI_BACKENDS,
     ),
     Operation(
         "upload_certificate",

{python_netgear_switch_library-0.0.post345 → python_netgear_switch_library-0.0.post347}/src/netgear_switch/nsdp_write.py

@@ -33,6 +33,7 @@ from .models import VlanMode
 from .nsdp_read import AsyncNsdpReader, NsdpReader
 from .protocols.nsdp.protocol import Tag
 from .protocols.nsdp.write import (
+    hostname_tlv,
     ipv4_tlv,
     pvid_tlv,
     vlan_destroy_tlv,
@@ -132,6 +133,28 @@ class NsdpWriter:
     def _vlan(self, vlan: int) -> VLANInfo | None:
         return next((v for v in self._reader.get_vlans() if v.vlan_id == vlan), None)
 
+    def set_hostname(self, name: str, *, force: bool = False) -> None:
+        """Set the switch's host name over NSDP (tag 0x0003).
+
+        The Plus family's only write route for this: those switches have no SNMP
+        agent and no CLI, so without this they cannot be renamed at all.
+
+        Not force-gated -- renaming cannot strand a switch, and it is reversible
+        by writing the old name back. Verified by re-reading the tag.
+        """
+        del force  # accepted for a uniform writer signature; nothing to gate
+        if not name.strip():
+            raise ValueError("hostname must not be empty")
+        before = self._reader.get_hostname()
+        self.client.write([hostname_tlv(name)], password=self._password)
+        after = self._reader.get_hostname()
+        if after != name:
+            raise WriteVerificationError(
+                f"host name is {after!r} after writing {name!r}",
+                before=before,
+                after=after,
+            )
+
     def set_pvid(self, port: int, vlan: int, *, force: bool = False) -> None:
         # LIVE-VERIFIED over NSDP v2 on a GS110EMX (fw 1.0.2.8): PORT_PVID
         # (0x3000) IS writable (the reference spec's READ-ONLY marking was

{python_netgear_switch_library-0.0.post345 → python_netgear_switch_library-0.0.post347}/src/netgear_switch/protocols/nsdp/write.py

@@ -157,6 +157,17 @@ def port_name_tlv(port: int, name: str) -> TLVEntry:
     return TLVEntry(Tag.PORT_NAME, bytes([port]) + name.encode("utf-8"))
 
 
+def hostname_tlv(name: str) -> TLVEntry:
+    """Host-name write TLV (tag 0x0003), the same shape the read decodes.
+
+    The read side is measured -- ``parsers`` decodes this tag as plain text and
+    three live GS110EMX report their names through it -- so the write is that
+    encoding with nothing added: the bare name, ASCII, no length prefix and no
+    port byte (unlike ``port_name_tlv`` above, whose tag is indexed by port).
+    """
+    return TLVEntry(Tag.HOSTNAME, name.encode("ascii"))
+
+
 def ipv4_tlv(tag: Tag, dotted: str) -> TLVEntry:
     return TLVEntry(tag, socket.inet_aton(dotted))
 

{python_netgear_switch_library-0.0.post345 → python_netgear_switch_library-0.0.post347}/src/netgear_switch/sync_api.py

@@ -157,6 +157,8 @@ if TYPE_CHECKING:
         PortStats,
         PortStatus,
         Sensor,
+        ServiceStatus,
+        SwitchUser,
         SyslogConfig,
         VLANInfo,
         VlanMode,
@@ -564,6 +566,23 @@ class SyncSwitch:
         """
         return self._read(lambda r: r.get_syslog(), backend)
 
+    def get_users(self, *, backend: Backend | None = None) -> list[SwitchUser]:
+        """The switch's local login accounts.
+
+        Served over the FASTPATH CLI. ``SwitchUser.access_mode`` keeps the
+        firmware's own wording, which differs between images, and
+        ``privileged`` carries the normalised reading.
+        """
+        return self._read(lambda r: r.get_users(), backend)
+
+    def get_services(self, *, backend: Backend | None = None) -> list[ServiceStatus]:
+        """Which management services are enabled, and on which ports.
+
+        Served over the FASTPATH CLI. A ``port`` of ``None`` means the firmware
+        reports no port for that service, not that a default applies.
+        """
+        return self._read(lambda r: r.get_services(), backend)
+
     def get_hostname(self, *, backend: Backend | None = None) -> str:
         """The switch's host name.