feat(snmp): devices you add, test and read on the SNMP page (milestone 491)

The operator, reviewing SNMP on #5214: "this system looks incomplete like
there's something missing from it". The one device shown was plugin.yaml's
example (core-switch 192.168.1.1, community public), polled every minute;
devices could only be defined by editing YAML in the image; a failed poll was
logged at DEBUG and stored nowhere, so the page said "waiting for the next
poll" forever; v3 ran as v2c; counters showed as lifetime totals.

- Devices are rows (snmp_devices, migration snmp_001): address, port,
  v1/v2c community or a v3 user with auth/priv protocols and keys (secrets
  encrypted), presets plus custom readings, an optional host binding, and
  the newest poll's outcome. The YAML device list and its example are gone.
- The SNMP page adds, edits and deletes them (admin, audited, with
  get_audit_entities so the audit log names and links a device). Readings
  come from presets (system uptime, interface traffic by number, UPS-MIB,
  Linux net-snmp) and custom "OID name [unit]" lines.
- One GET per device with every OID, devices polled at once. The outcome is
  written to the row in words ("No reply from … within 5 s. Check the address
  and port, that SNMP is on, and the community"), with readings it lacks.
  v1's whole-request error drops that OID and asks again. SNMPv3 signs in
  with USM (MD5/SHA-1/SHA-2, DES/3DES/AES).
- Test asks the unsaved form's device for its name, description, uptime and
  interfaces by number. It is an admin's explicit action; every page reads
  only stored rows (System 178's ruling).
- Each reading has a unit; a counter is stored as a per-second rate (bytes as
  bit/s), a reset or wrap skipped. The page, widget and host panel say values
  in units and why a device is silent; the device page draws a chart per
  reading on a dated axis.

Tests: readings and presets, the form and its secrets, v3 checks, rates,
the poller against a stand-in pysnmp (one GET, v1 retry, timeout wording,
USM), the pages, and an integration test of the poll writing outcomes and
rates on Postgres.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

plugins/snmp/scheduler.py

@@ -1,15 +1,23 @@
 # plugins/snmp/scheduler.py
 from __future__ import annotations
+
+import asyncio
 import logging
+from datetime import datetime, timezone
 from typing import TYPE_CHECKING
 
+from sqlalchemy import select
+
+from steward.core.scheduler import ScheduledTask
+
 if TYPE_CHECKING:
     from quart import Quart
 
-from steward.core.scheduler import ScheduledTask
-
 logger = logging.getLogger(__name__)
 
+# Counters' previous samples, for their rates (service.RateKeeper).
+RATES = None
+
 
 def make_poll_task(app: "Quart") -> ScheduledTask:
     interval = app.config["PLUGINS"]["snmp"].get("poll_interval_seconds", 60)
@@ -25,46 +33,58 @@ def make_poll_task(app: "Quart") -> ScheduledTask:
     )
 
 
-async def _do_poll(app: "Quart") -> None:
-    from .poller import poll_device
+async def _do_poll(app: "Quart", poll=None) -> None:
+    """Poll every device at once, then write each one's outcome to its row
+    and its answers to the metric tables. `poll` stands in for
+    poller.poll_device in tests."""
+    global RATES
     from steward.core.alerts import MetricBatch
 
-    devices: list[dict] = app.config["PLUGINS"]["snmp"].get("devices", [])
+    from .models import SnmpDevice
+    from .poller import poll_device
+    from .service import RateKeeper, credentials, readings_for
+
+    poll = poll or poll_device
+    if RATES is None:
+        RATES = RateKeeper()
+
+    async with app.db_sessionmaker() as session:
+        devices = (await session.execute(select(SnmpDevice))).scalars().all()
     if not devices:
         return
 
+    asked = {d.id: readings_for(d) for d in devices}
+    results = await asyncio.gather(*(
+        poll(d.address, d.port, credentials(d), [(r.oid, r.key) for r in asked[d.id]])
+        for d in devices), return_exceptions=True)
+
+    now = datetime.now(timezone.utc)
     async with app.db_sessionmaker() as session:
         async with session.begin():
             batch = MetricBatch()
-            for device in devices:
-                if not isinstance(device, dict):
+            for device, result in zip(devices, results):
+                row = await session.get(SnmpDevice, device.id)
+                if row is None:          # deleted while it was being polled
                     continue
-                name = device.get("name") or device.get("host", "unknown")
-                host = device.get("host", "")
-                port = int(device.get("port", 161))
-                community = device.get("community", "public")
-                version = str(device.get("version", "2c"))
-                oids = device.get("oids", [])
-
-                if not host or not oids:
+                row.last_polled_at = now
+                if isinstance(result, BaseException):
+                    logger.warning("SNMP poll of %s failed: %s", device.name, result)
+                    row.last_error = f"SNMP poll failed: {result}"
                     continue
-
-                try:
-                    readings = await poll_device(host, port, community, version, oids)
-                except Exception:
-                    logger.exception("SNMP poll failed for device %s (%s)", name, host)
-                    continue
-
-                for label, value in readings.items():
-                    batch.add(
-                        source_module="snmp",
-                        resource_name=name,
-                        metric_name=label,
-                        value=value,
-                    )
-
-                if readings:
-                    logger.debug("SNMP polled %s (%s): %d OID(s)", name, host, len(readings))
-                else:
-                    logger.debug("SNMP polled %s (%s): no readings", name, host)
+                row.last_error = result.error
+                row.missing = sorted(set(result.missing))
+                if result.readings:
+                    row.last_ok_at = now
+                for reading in asked[device.id]:
+                    value = result.readings.get(reading.key)
+                    if value is None:
+                        continue
+                    if reading.counter:
+                        value = RATES.rate(device.id, reading, value, now)
+                        if value is None:
+                            continue
+                    else:
+                        value = value * reading.scale + reading.offset
+                    batch.add(source_module="snmp", resource_name=device.name,
+                              metric_name=reading.key, value=value, recorded_at=now)
             await batch.record(session)