Animate netmap traffic, add remote-host pages, page-level overrides

- netmap: spokes with live traffic (Prometheus rate query, cached 5s)
  get flowing packet dots, brighter lines, and a rate label under the
  hostname; animation clock is wall-time so any refresh rate works
- carousel: per-page dwell/refresh overrides (netmap page runs at 0.5s
  for smooth dots), `disabled: true` parks a page without deleting it
- derived expressions get helpers: human_rate min max round int str abs
- PVE2/PROXMOX host pages: identical layout to the local HOST page by
  overriding local value names (cpu_pct, ram_pct, ...) with per-instance
  node-exporter queries; NIC regex includes PVE 9 pinned names (nic0)
- rotation now 60s/page; CYBERDECK parked via disabled flag

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: Fumunchu

apps/carousel.py

@@ -31,9 +31,12 @@ def page_values(page, sources):
         else:
             src, query = sources.get("prom"), q
         vals[name] = src.value(query) if src else None
+    env = {"__builtins__": {}, "human_rate": c.human_rate,
+           "min": min, "max": max, "round": round, "int": int,
+           "str": str, "abs": abs}
     for name, expr in (page.get("derived") or {}).items():
         try:
-            vals[name] = eval(expr, {"__builtins__": {}}, dict(vals))
+            vals[name] = eval(expr, env, dict(vals))
         except Exception:
             vals[name] = None
     return vals
@@ -79,8 +82,11 @@ def run(lcd, display_cfg):
     sources = c.build_sources(display_cfg)
     cfg = load_pages_cfg(pages_file)
 
+    def active_pages(cfg):
+        return [p for p in (cfg.get("pages") or []) if not p.get("disabled")]
+
     if os.environ.get("ONCE") == "1":
-        pages = cfg.get("pages") or []
+        pages = active_pages(cfg)
         for k, page in enumerate(pages):
             p = f"/tmp/carousel_{k}.png"
             render_page(page, k, len(pages), sources, display_cfg).save(p)
@@ -103,14 +109,14 @@ def run(lcd, display_cfg):
             cfg = load_pages_cfg(pages_file)  # live reload; keep last good on error
         except Exception:
             pass
-        pages = cfg.get("pages") or []
+        pages = active_pages(cfg)
         if not pages:
             time.sleep(2)
             continue
         idx %= len(pages)
         page = pages[idx]
-        dwell = float(cfg.get("dwell", 8))
-        refresh = float(cfg.get("refresh", 2))
+        dwell = float(page.get("dwell") or cfg.get("dwell", 8))
+        refresh = float(page.get("refresh") or cfg.get("refresh", 2))
 
         frame = render_page(page, idx, len(pages), sources, display_cfg)
         c.push_frame(lcd, frame, prev)

apps/netmap.py

@@ -16,39 +16,67 @@
 from apps import common as c
 
 LINE_UP = (40, 90, 70)
+LINE_ACTIVE = (60, 140, 105)
 LINE_DOWN = (90, 40, 40)
 
+_DEV_SKIP = 'device!~"lo|veth.+|cni.+|flannel.+|docker.+|br.+|vmbr.+|fw.+|tap.+"'
+DEFAULT_TRAFFIC_QUERY = (
+    f"sum by (instance) (rate(node_network_receive_bytes_total{{{_DEV_SKIP}}}[2m])"
+    f" + rate(node_network_transmit_bytes_total{{{_DEV_SKIP}}}[2m]))")
+
+_CACHE = {"t": 0.0, "hosts": []}
+
 
 def gather_hosts(src, nm_cfg):
+    """[(name, up, traffic_bps)] -- cached so fast animation frames don't hammer
+    Prometheus (data refreshes every `data_refresh` seconds, default 5)."""
+    now = time.monotonic()
+    if _CACHE["hosts"] and now - _CACHE["t"] < float(nm_cfg.get("data_refresh", 5)):
+        return _CACHE["hosts"]
     up_query = nm_cfg.get("up_query", 'up{job=~".*node.*"}')
     names = {m.get("instance"): m.get("nodename")
              for m, _ in src.series("node_uname_info")}
+    traffic = {}
+    for m, v in src.series(nm_cfg.get("traffic_query", DEFAULT_TRAFFIC_QUERY)):
+        name = names.get(m.get("instance")) or m.get("instance", "?").split(":")[0]
+        traffic[name] = traffic.get(name, 0.0) + v
     hosts = {}
     for m, v in src.series(up_query):
         inst = m.get("instance", "?")
         name = names.get(inst) or inst.split(":")[0].removesuffix(".local")
         hosts[name] = max(hosts.get(name, 0.0), v)  # any up target counts as up
-    return sorted(hosts.items())
+    result = sorted((n, u, traffic.get(n, 0.0)) for n, u in hosts.items())
+    _CACHE.update(t=now, hosts=result)
+    return result
 
 
 def render(hosts, nm_cfg, idx=None, npages=None):
     img = Image.new("RGB", (c.W, c.H), c.BG)
     d = ImageDraw.Draw(img)
-    n_up = sum(1 for _, v in hosts if v >= 1)
+    n_up = sum(1 for _, v, _ in hosts if v >= 1)
     c.header(d, nm_cfg.get("title", "NETWORK MAP"), idx, npages)
     count_x = c.W - 16 - (18 * npages + 16 if npages else 0)  # clear the page dots
     d.text((count_x, 22), f"{n_up}/{len(hosts)} up",
            font=c.font(16, "B", "mono"),
            fill=c.COLORS["ok"] if n_up == len(hosts) else c.COLORS["bad"], anchor="rm")
 
     cx, cy, rx, ry = c.W // 2, 176, 168, 92
+    traffic_min = float(nm_cfg.get("traffic_min", 5000))  # B/s to count as active
+    phase = (time.monotonic() % 2.0) / 2.0  # shared animation clock, 2s cycle
     # spokes + nodes
-    for k, (name, up) in enumerate(hosts):
+    for k, (name, up, traffic) in enumerate(hosts):
         a = 2 * math.pi * k / max(1, len(hosts)) - math.pi / 2
         px = cx + int(rx * math.cos(a))
         py = cy + int(ry * math.sin(a))
         ok = up >= 1
-        d.line([cx, cy, px, py], fill=LINE_UP if ok else LINE_DOWN, width=2)
+        active = ok and traffic >= traffic_min
+        d.line([cx, cy, px, py],
+               fill=(LINE_ACTIVE if active else LINE_UP) if ok else LINE_DOWN, width=2)
+        if active:  # packets flowing outward along the spoke
+            for j in range(2):
+                f = 0.22 + 0.62 * ((phase + j / 2) % 1.0)
+                dx, dy = cx + (px - cx) * f, cy + (py - cy) * f
+                d.ellipse([dx - 3, dy - 3, dx + 3, dy + 3], fill=c.COLORS["accent"])
         col = c.COLORS["ok"] if ok else c.COLORS["bad"]
         d.ellipse([px - 6, py - 6, px + 6, py + 6], fill=col)
         if not ok:  # ring downed hosts so they pop
@@ -58,6 +86,10 @@ def render(hosts, nm_cfg, idx=None, npages=None):
         lx = min(max(px, 40), c.W - 40)
         d.text((lx, ly), name, font=f,
                fill=c.COLORS["fg"] if ok else c.COLORS["bad"], anchor="ma")
+        if active:  # current rate under the hostname
+            ry_off = ly - 14 if py < cy else ly + 16
+            d.text((lx, ry_off), c.human_rate(traffic), font=c.font(10),
+                   fill=c.COLORS["dim"], anchor="ma")
     # gateway hub on top of the spokes
     label = str(nm_cfg.get("center_label", "LAN"))
     d.ellipse([cx - 26, cy - 26, cx + 26, cy + 26], fill=c.PANEL,

pages.yaml

@@ -23,9 +23,14 @@
 # Page options:
 #   background: res/themes/<name>/background.png   draw widgets over theme art
 #   header: false / footer: false                  hide chrome (for art pages)
+#   disabled: true                                 keep the page, skip the rotation
+#   dwell / refresh                                per-page overrides of the globals
 #   queries:  name: <promql>                       value from the default `prom` source
 #             name: {source: <name>, query: ...}   value from a named source (display.yaml)
-#   derived:  name: <python expr over values>      computed values
+#   derived:  name: <python expr over values>      computed values; helpers available:
+#                                                  human_rate min max round int str abs
+#   NOTE: queries/derived may reuse local value names (cpu_pct, ram_pct, ...) to
+#   override them -- that's how remote-host pages reuse the HOST widget layout.
 #
 # text format: python format string over the value namespace; unavailable -> "-".
 # Local values (always): cpu_pct ram_pct ram_used_g ram_total_g disk_pct
@@ -38,7 +43,7 @@
 #   auto:<name>[:warn:bad]                   green/amber/red by thresholds (default 70:90)
 #   ok_if:<expr>[:<else-color>]              OK when expr true, else bad (or <else-color>)
 
-dwell: 8
+dwell: 60
 refresh: 2
 
 pages:
@@ -98,12 +103,81 @@ pages:
       - {type: metric, x: 16,  y: 170, label: CPU,      text: "{cpu:.0f}%", color: "auto:cpu"}
       - {type: metric, x: 176, y: 170, label: MEM,      text: "{mem:.0f}%", color: "auto:mem"}
 
-  # The netmap app embedded as a page (settings inherit from display.yaml `netmap:`)
+  # The netmap app embedded as a page (settings inherit from display.yaml `netmap:`).
+  # Fast refresh animates the packet dots on spokes with live traffic; host/traffic
+  # data itself is cached and only re-queried every `data_refresh` (5s) seconds.
   - type: netmap
+    refresh: 0.5
+
+  - title: PVE2 HOST
+    queries:
+      cpu_pct: 100-(avg(rate(node_cpu_seconds_total{instance="pve2.local:9100",mode="idle"}[2m]))*100)
+      ram_t:   node_memory_MemTotal_bytes{instance="pve2.local:9100"}
+      ram_a:   node_memory_MemAvailable_bytes{instance="pve2.local:9100"}
+      disk_t:  node_filesystem_size_bytes{instance="pve2.local:9100",mountpoint="/"}
+      disk_a:  node_filesystem_avail_bytes{instance="pve2.local:9100",mountpoint="/"}
+      temp:    max(node_hwmon_temp_celsius{instance="pve2.local:9100"})
+      load1:   node_load1{instance="pve2.local:9100"}
+      up_s:    time()-node_boot_time_seconds{instance="pve2.local:9100"}
+      net_down: sum(rate(node_network_receive_bytes_total{instance="pve2.local:9100",device=~"en.*|eth.*|nic.*"}[2m]))
+      net_up:   sum(rate(node_network_transmit_bytes_total{instance="pve2.local:9100",device=~"en.*|eth.*|nic.*"}[2m]))
+    derived:
+      ram_pct:      "100*(1-ram_a/ram_t)"
+      ram_used_g:   "(ram_t-ram_a)/1e9"
+      ram_total_g:  "ram_t/1e9"
+      disk_pct:     "100*(1-disk_a/disk_t)"
+      disk_used_g:  "(disk_t-disk_a)/1e9"
+      disk_total_g: "disk_t/1e9"
+      uptime:       "str(int(up_s//86400))+'d '+str(int(up_s%86400//3600))+'h'"
+      net_down_h:   "human_rate(net_down)"
+      net_up_h:     "human_rate(net_up)"
+    widgets:
+      - {type: bar,    x: 16,  y: 62,  w: 250, label: CPU,    pct: cpu_pct,  text: "{cpu_pct:.0f}%"}
+      - {type: bar,    x: 16,  y: 122, w: 250, label: RAM,    pct: ram_pct,  text: "{ram_used_g:.1f}/{ram_total_g:.0f}G"}
+      - {type: bar,    x: 16,  y: 182, w: 250, label: DISK /, pct: disk_pct, text: "{disk_used_g:.0f}/{disk_total_g:.0f}G"}
+      - {type: metric, x: 300, y: 58,  label: TEMP,   text: "{temp:.0f}°C", color: "auto:temp:75:90"}
+      - {type: metric, x: 300, y: 138, label: LOAD,   text: "{load1:.2f}"}
+      - {type: metric, x: 300, y: 218, label: UPTIME, text: "{uptime}"}
+      - {type: text,   x: 16,  y: 254, size: 13, anchor: lm, text: "DN {net_down_h}"}
+      - {type: text,   x: 16,  y: 274, size: 13, anchor: lm, text: "UP {net_up_h}"}
+
+  - title: PROXMOX HOST
+    queries:
+      cpu_pct: 100-(avg(rate(node_cpu_seconds_total{instance="proxmox.local:9100",mode="idle"}[2m]))*100)
+      ram_t:   node_memory_MemTotal_bytes{instance="proxmox.local:9100"}
+      ram_a:   node_memory_MemAvailable_bytes{instance="proxmox.local:9100"}
+      disk_t:  node_filesystem_size_bytes{instance="proxmox.local:9100",mountpoint="/"}
+      disk_a:  node_filesystem_avail_bytes{instance="proxmox.local:9100",mountpoint="/"}
+      temp:    max(node_hwmon_temp_celsius{instance="proxmox.local:9100"})
+      load1:   node_load1{instance="proxmox.local:9100"}
+      up_s:    time()-node_boot_time_seconds{instance="proxmox.local:9100"}
+      net_down: sum(rate(node_network_receive_bytes_total{instance="proxmox.local:9100",device=~"en.*|eth.*|nic.*"}[2m]))
+      net_up:   sum(rate(node_network_transmit_bytes_total{instance="proxmox.local:9100",device=~"en.*|eth.*|nic.*"}[2m]))
+    derived:
+      ram_pct:      "100*(1-ram_a/ram_t)"
+      ram_used_g:   "(ram_t-ram_a)/1e9"
+      ram_total_g:  "ram_t/1e9"
+      disk_pct:     "100*(1-disk_a/disk_t)"
+      disk_used_g:  "(disk_t-disk_a)/1e9"
+      disk_total_g: "disk_t/1e9"
+      uptime:       "str(int(up_s//86400))+'d '+str(int(up_s%86400//3600))+'h'"
+      net_down_h:   "human_rate(net_down)"
+      net_up_h:     "human_rate(net_up)"
+    widgets:
+      - {type: bar,    x: 16,  y: 62,  w: 250, label: CPU,    pct: cpu_pct,  text: "{cpu_pct:.0f}%"}
+      - {type: bar,    x: 16,  y: 122, w: 250, label: RAM,    pct: ram_pct,  text: "{ram_used_g:.1f}/{ram_total_g:.0f}G"}
+      - {type: bar,    x: 16,  y: 182, w: 250, label: DISK /, pct: disk_pct, text: "{disk_used_g:.0f}/{disk_total_g:.0f}G"}
+      - {type: metric, x: 300, y: 58,  label: TEMP,   text: "{temp:.0f}°C", color: "auto:temp:75:90"}
+      - {type: metric, x: 300, y: 138, label: LOAD,   text: "{load1:.2f}"}
+      - {type: metric, x: 300, y: 218, label: UPTIME, text: "{uptime}"}
+      - {type: text,   x: 16,  y: 254, size: 13, anchor: lm, text: "DN {net_down_h}"}
+      - {type: text,   x: 16,  y: 274, size: 13, anchor: lm, text: "UP {net_up_h}"}
 
   # Live values over the stock Cyberdeck theme art: radials trace the ring art,
   # text widgets sit in its value boxes. GPU ring shows disk until the GPU lands.
+  # Parked from the rotation -- flip `disabled` to bring it back.
   - title: CYBERDECK
+    disabled: true
     background: res/themes/Cyberdeck/background.png
     header: false
     footer: false