Compare commits

...
Author SHA1 Message Date
jared 6530433d9c Merge pull request 'Rack: clicking a port on an unlinked faceplate opens the cutsheet' (#28) from rack-unlinked-port-clicks into main
Lint / JS (eslint) (push) Successful in 8s
Lint / Python (flake8) (push) Successful in 49s
Lint / Notify on failure (push) Skipped
Security / Python Security (bandit) (push) Successful in 55s
Lint / Deploy (push) Successful in 6s
Test / Python Tests (pytest) (push) Successful in 1m20s
2026-11-10 23:54:51 -05:00
jaredandClaude Opus 5.5 5fdd317539 Rack: clicking a port on an unlinked faceplate opens the cutsheet
Lint / JS (eslint) (push) Successful in 8s
Lint / Python (flake8) (push) Successful in 50s
Lint / Notify on failure (push) Skipped
Security / Python Security (bandit) (push) Successful in 1m8s
Lint / JS (eslint) (pull_request) Successful in 22s
Lint / Python (flake8) (pull_request) Successful in 1m49s
Lint / Deploy (pull_request) Skipped
Lint / Deploy (push) Skipped
Lint / Notify on failure (pull_request) Skipped
Security / Python Security (bandit) (pull_request) Successful in 1m12s
Test / Python Tests (pytest) (pull_request) Successful in 1m9s
Test / Python Tests (pytest) (push) Successful in 1m3s
The NVR Pro is drawn by Front drawing because UniFi doesn't report it, so
it has no device page; clicking one of its ports went to /device/UNVR-Pro
and showed "No device with this name". Ports on a faceplate whose item
isn't linked to a live device now open the port's cable when one is
documented, and otherwise the item on the cutsheet.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 23:53:18 -05:00
jared 3e2918526f Merge pull request 'Rack: drawn fronts (NVR Pro, UACC panel, server cases), faceplate labels, no em/en dashes' (#27) from rack-drawn-fronts into main
Lint / Python (flake8) (push) Successful in 50s
Lint / JS (eslint) (push) Successful in 10s
Lint / Notify on failure (push) Skipped
Security / Python Security (bandit) (push) Successful in 2m0s
Test / Python Tests (pytest) (push) Successful in 2m4s
Lint / Deploy (push) Successful in 8s
2026-11-10 23:45:36 -05:00
jaredandClaude Opus 5.5 50db56cdcb Rack: draw the UniFi UACC blank 24-port keystone patch panel
Lint / JS (eslint) (push) Successful in 7s
Lint / Python (flake8) (push) Successful in 58s
Lint / Notify on failure (push) Skipped
Lint / JS (eslint) (pull_request) Successful in 11s
Lint / Python (flake8) (pull_request) Successful in 1m6s
Lint / Deploy (pull_request) Skipped
Security / Python Security (bandit) (push) Successful in 1m0s
Lint / Deploy (push) Skipped
Lint / Notify on failure (pull_request) Skipped
Test / Python Tests (pytest) (push) Successful in 1m59s
Security / Python Security (bandit) (pull_request) Successful in 1m42s
Test / Python Tests (pytest) (pull_request) Successful in 1m0s
Front drawing "UniFi Patch Panel Blank 24" draws the real panel, laid out
from the CC0 NetBox devicetype-library image: grey steel face, darker ears
with oval holes, 24 keystone openings with the cable-support bar behind
them, and a cable slot at each end. Ports with a documented cable get a
keystone jack; cutsheet marks, port labels and run highlighting work as on
the generic panel.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 23:39:27 -05:00
jaredandClaude Opus 5.5 619a2c913d Remove em and en dashes from the UI, code and docs
Lint / JS (eslint) (push) Successful in 7s
Lint / Python (flake8) (push) Successful in 57s
Lint / Notify on failure (push) Skipped
Security / Python Security (bandit) (push) Successful in 57s
Lint / JS (eslint) (pull_request) Successful in 10s
Lint / Python (flake8) (pull_request) Successful in 51s
Lint / Deploy (pull_request) Skipped
Lint / Deploy (push) Skipped
Lint / Notify on failure (pull_request) Skipped
Security / Python Security (bandit) (pull_request) Successful in 1m0s
Test / Python Tests (pytest) (push) Successful in 1m3s
Test / Python Tests (pytest) (pull_request) Successful in 52s
Page titles read "Rack | GANDALF", ranges use a hyphen (U26-42,
1-100 of 300), empty cells show "-", and dash-separated phrases use a
colon, comma or full stop. In the shared base.js only the on-screen strings
changed (boot line, placeholders, offline banner and toast).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 23:37:56 -05:00
jaredandClaude Opus 5.5 3c9e5fd593 Faceplates: model labels as printed on the units
Lint / JS (eslint) (push) Successful in 16s
Lint / Python (flake8) (push) Successful in 1m6s
Lint / Notify on failure (push) Skipped
Lint / Python (flake8) (pull_request) Successful in 52s
Lint / JS (eslint) (pull_request) Successful in 7s
Lint / Deploy (pull_request) Skipped
Security / Python Security (bandit) (push) Successful in 54s
Lint / Deploy (push) Skipped
Lint / Notify on failure (pull_request) Skipped
Security / Python Security (bandit) (pull_request) Successful in 53s
Test / Python Tests (pytest) (push) Successful in 2m11s
Test / Python Tests (pytest) (pull_request) Successful in 2m16s
The label under each UniFi screen was one weight, left-aligned, and on the
UDM read "Dream Machine Pro". Checked against the NetBox reference photos
(and the UDM against the real unit), the labels are now centred under the
screen with the first word bold and the rest light: "UDM Pro",
"USW Pro" with its PoE mark, "USW", "NVR Pro", "USP PDU Pro". One helper
(fpModel) draws them all, so the NVR no longer looks bolder than the
switches.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 23:36:23 -05:00
jaredandClaude Opus 5.5 565fdd81de Rack: NVR Pro as a real faceplate; Sliger and Rosewill touch-ups
Lint / JS (eslint) (push) Successful in 18s
Security / Python Security (bandit) (push) Successful in 1m45s
Lint / Python (flake8) (push) Successful in 1m25s
Lint / Notify on failure (push) Skipped
Lint / Python (flake8) (pull_request) Successful in 52s
Lint / JS (eslint) (pull_request) Successful in 6s
Lint / Deploy (pull_request) Skipped
Lint / Deploy (push) Skipped
Lint / Notify on failure (pull_request) Skipped
Test / Python Tests (pytest) (push) Successful in 1m18s
Security / Python Security (bandit) (pull_request) Successful in 56s
Test / Python Tests (pytest) (pull_request) Successful in 53s
The hand-drawn NVR Pro didn't match the UniFi faceplates: flat colours,
low contrast and its own port shapes. It is now a FACEPLATES entry
(UNVRPRO) built from the same parts as the UDM Pro: metal body, RJ45 jack,
SFP+ cage, quad screen, vents and labels. Front drawing "UniFi NVR Pro"
uses it, and it would go live if UniFi ever reports the model.

Sliger bays are numbered 1-10 (driveAtlas's order); the Rosewill door is
perforated with a latch.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 23:31:19 -05:00
jaredandClaude Opus 5.5 0f4e129c20 Rack: drawn fronts for the NVR and server cases
Lint / JS (eslint) (push) Successful in 15s
Security / Python Security (bandit) (push) Successful in 1m5s
Lint / Python (flake8) (push) Successful in 49s
Lint / Notify on failure (push) Skipped
Lint / Python (flake8) (pull_request) Successful in 53s
Lint / JS (eslint) (pull_request) Successful in 7s
Lint / Deploy (pull_request) Skipped
Lint / Deploy (push) Skipped
Test / Python Tests (pytest) (push) Successful in 1m0s
Lint / Notify on failure (pull_request) Skipped
Security / Python Security (bandit) (pull_request) Successful in 53s
Test / Python Tests (pytest) (pull_request) Successful in 57s
Items Gandalf has no live faceplate for can pick a Front drawing: the
UniFi NVR Pro (drawn from the CC0 NetBox devicetype-library image), the
Sliger CX4712 4U and Rosewill RSV-L4500U 4U cases (from driveAtlas's
layouts), and generic 1U/2U/4U servers. The power light shows the linked
device's live status. They export with the rest of the rack.

New cutsheet_items column chassis, added on first use.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 23:25:02 -05:00
jared b416239438 Merge pull request 'Rack: put a patch panel's name above its ports' (#26) from rack-panel-label into main
Lint / JS (eslint) (push) Successful in 7s
Lint / Python (flake8) (push) Successful in 55s
Lint / Notify on failure (push) Skipped
Security / Python Security (bandit) (push) Successful in 1m10s
Lint / Deploy (push) Successful in 7s
Test / Python Tests (pytest) (push) Successful in 51s
2026-11-10 23:20:22 -05:00
jaredandClaude Opus 5.5 97e6692ebf Rack: put a patch panel's name above its ports
Lint / JS (eslint) (push) Successful in 8s
Lint / Python (flake8) (push) Successful in 51s
Lint / Notify on failure (push) Skipped
Security / Python Security (bandit) (push) Successful in 54s
Lint / Python (flake8) (pull_request) Successful in 1m7s
Lint / JS (eslint) (pull_request) Successful in 13s
Lint / Deploy (pull_request) Skipped
Lint / Deploy (push) Skipped
Test / Python Tests (pytest) (push) Successful in 1m21s
Lint / Notify on failure (pull_request) Skipped
Security / Python Security (bandit) (pull_request) Successful in 1m18s
Test / Python Tests (pytest) (pull_request) Successful in 1m5s
A long panel name (UACC-Rack-Panel-Patch-Blank-24) was drawn in the left
ear at full size and ran under the ports. It is now a small caption in
the panel's top-left corner, shortened past 48 characters with the full
name in its tooltip.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 23:02:18 -05:00
jared bee260f1cd Merge pull request 'Rack: front and rear mounting, rack settings on the page' (#25) from rack-rear-and-settings into main
Lint / JS (eslint) (push) Successful in 8s
Lint / Python (flake8) (push) Successful in 54s
Lint / Notify on failure (push) Skipped
Security / Python Security (bandit) (push) Successful in 52s
Lint / Deploy (push) Successful in 4s
Test / Python Tests (pytest) (push) Successful in 1m44s
2026-11-10 22:52:15 -05:00
jaredandClaude Opus 5.5 c50e1f8322 Rack: front and rear mounting, rack settings in the page
Lint / JS (eslint) (push) Successful in 7s
Lint / Python (flake8) (push) Successful in 49s
Lint / Notify on failure (push) Skipped
Security / Python Security (bandit) (push) Successful in 51s
Lint / Python (flake8) (pull_request) Successful in 55s
Lint / JS (eslint) (pull_request) Successful in 7s
Lint / Deploy (pull_request) Skipped
Lint / Deploy (push) Skipped
Test / Python Tests (pytest) (push) Successful in 1m4s
Lint / Notify on failure (pull_request) Skipped
Security / Python Security (bandit) (pull_request) Successful in 52s
Test / Python Tests (pytest) (pull_request) Successful in 55s
Items are mounted from the front, the rear, or full depth. On a 4-post
rack a front and a rear item can share a unit; a full-depth one takes
both sides, and the rear view shows its back. Overlaps are checked per
side. Shelf contents take the shelf's side. A Front / Rear switch flips
the drawing.

Racks are saved in Gandalf (new cutsheet_racks table) and edited on the
rack page by admins: name, height, notes, add and delete. Renaming moves
the rack's items; saving the first rack carries over the items of the
config default it replaces. Config racks remain the fallback.

Faceplates are stretched to the full width only when the drawing is
close to the slot's proportions, so the PDU is not squashed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 22:35:37 -05:00
jared cd3d2f05ee Merge pull request 'Rack: device links, shelves, multiple racks, export; layout and light-mode fixes' (#24) from racks-shelves-export into main
Lint / JS (eslint) (push) Successful in 7s
Lint / Python (flake8) (push) Successful in 54s
Lint / Notify on failure (push) Skipped
Security / Python Security (bandit) (push) Successful in 55s
Lint / Deploy (push) Successful in 4s
Test / Python Tests (pytest) (push) Successful in 1m5s
2026-11-10 22:29:38 -05:00
jaredandClaude Opus 5.5 bdd68a397d Rack: link items to devices, shelves, several racks, export; fix layout and light mode
Lint / JS (eslint) (push) Successful in 7s
Lint / Python (flake8) (push) Successful in 48s
Lint / Notify on failure (push) Skipped
Security / Python Security (bandit) (push) Successful in 49s
Lint / Python (flake8) (pull_request) Successful in 51s
Lint / JS (eslint) (pull_request) Successful in 7s
Lint / Deploy (pull_request) Skipped
Lint / Deploy (push) Skipped
Test / Python Tests (pytest) (push) Successful in 1m2s
Lint / Notify on failure (pull_request) Skipped
Security / Python Security (bandit) (pull_request) Successful in 50s
Test / Python Tests (pytest) (pull_request) Successful in 53s
Cutsheet items gain a "Gandalf device" link, so an item named after the
product (UDM-Pro) shows the live device's faceplate, ports and status.
Cable checks, suggestions, tickets and the device page treat an item and
its linked device as one. Without this, product-named items drew as bare
name plates.

Items can sit on a shelf instead of a rack unit; the shelf draws what is
on it with live status. Items have a rack, the page shows a tab per rack
(config "racks"), and a rack can be downloaded as SVG or PNG.

The rack is centred, long runs of empty units fold into one band (with a
toggle), every device fills the 19" width, the UPS shows its front only,
and the rack keeps its own palette so it reads in light mode.

New cutsheet_items columns rack, shelf and device are added on first use.
Deleting a shelf, or making it something else, is refused while it holds
items; renaming it carries over.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 21:44:59 -05:00
jared 4f353888f8 Merge pull request 'Rack drawing (/rack)' (#23) from rack-view into main
Lint / JS (eslint) (push) Successful in 6s
Lint / Python (flake8) (push) Successful in 1m14s
Lint / Notify on failure (push) Skipped
Security / Python Security (bandit) (push) Successful in 1m41s
Lint / Deploy (push) Successful in 6s
Test / Python Tests (pytest) (push) Successful in 47s
2026-11-10 21:33:29 -05:00
jaredandClaude Opus 5.5 f655836446 Add a rack drawing (/rack)
Lint / JS (eslint) (push) Successful in 7s
Lint / Python (flake8) (push) Successful in 50s
Lint / Notify on failure (push) Skipped
Security / Python Security (bandit) (push) Successful in 50s
Lint / Python (flake8) (pull_request) Successful in 52s
Lint / JS (eslint) (pull_request) Successful in 7s
Lint / Deploy (pull_request) Skipped
Lint / Deploy (push) Skipped
Test / Python Tests (pytest) (push) Successful in 1m2s
Lint / Notify on failure (pull_request) Skipped
Security / Python Security (bandit) (pull_request) Successful in 1m42s
Test / Python Tests (pytest) (pull_request) Successful in 2m2s
The rack front is drawn from the rack units on cutsheet items. Switches
with a faceplate use it, with live port state; patch panels get a generic
panel with port labels; everything else is a labelled plate. Each
documented port shows its cutsheet state, and hovering a port lights up
every port on the same cable run (through patch panels) and names the
cables. Clicking opens the switch port or the cable.

Overlapping items and items past the top of the rack are listed instead
of drawn over another; where two claim the same top unit, the first one
recorded wins. rack.units sets the height (default 42).

/api/rack builds on the cutsheet view; cutsheet.rack_layout and
cutsheet.port_marks hold the placement and per-port logic.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 20:59:30 -05:00
jared ee2708dccb Merge pull request 'Inventory links, cutsheet marks on faceplates, single page titles' (#22) from inventory-and-faceplate-marks into main
Lint / JS (eslint) (push) Successful in 13s
Lint / Python (flake8) (push) Successful in 1m45s
Lint / Notify on failure (push) Skipped
Security / Python Security (bandit) (push) Successful in 1m32s
Lint / Deploy (push) Successful in 4s
Test / Python Tests (pytest) (push) Successful in 46s
2026-11-10 20:50:26 -05:00
jaredandClaude Opus 5.5 c262e5ecc8 Inventory links, cutsheet marks on faceplates, and single page titles
Lint / JS (eslint) (push) Successful in 7s
Lint / Python (flake8) (push) Successful in 54s
Lint / Notify on failure (push) Skipped
Security / Python Security (bandit) (push) Successful in 1m1s
Lint / JS (eslint) (pull_request) Successful in 19s
Lint / Python (flake8) (pull_request) Successful in 53s
Lint / Deploy (pull_request) Skipped
Lint / Deploy (push) Skipped
Test / Python Tests (pytest) (push) Successful in 2m6s
Security / Python Security (bandit) (pull_request) Successful in 1m18s
Test / Python Tests (pytest) (pull_request) Successful in 1m1s
Lint / Notify on failure (pull_request) Skipped
Device pages get an Inventory button: it opens the device's HomeBox record
once an admin pastes its URL (stored in the new device_links table; only
URLs on inventory.base_url are accepted), and searches the inventory for
the model until then. Tickets link the record too.

Faceplate ports with a documented cable get a corner dot: green matches,
red mismatch, grey documented but unconfirmed. The port's tooltip names
the cable, and a legend toggle (remembered per browser) hides them.

Page titles no longer repeat GANDALF ("Alert History - GANDALF - GANDALF").

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 20:47:14 -05:00
jared 29119c2235 Merge pull request 'Alert history page and a tighter monitor health check' (#21) from events-history into main
Lint / JS (eslint) (push) Successful in 9s
Lint / Python (flake8) (push) Successful in 1m19s
Lint / Notify on failure (push) Skipped
Security / Python Security (bandit) (push) Successful in 55s
Lint / Deploy (push) Successful in 4s
Test / Python Tests (pytest) (push) Successful in 48s
2026-11-10 20:37:45 -05:00
jaredandClaude Opus 5.5 9d561db703 Add an alert history page and tie /health staleness to the poll interval
Lint / JS (eslint) (push) Successful in 6s
Lint / Python (flake8) (push) Successful in 1m56s
Lint / Notify on failure (push) Skipped
Security / Python Security (bandit) (push) Successful in 2m3s
Lint / Python (flake8) (pull_request) Successful in 48s
Lint / JS (eslint) (pull_request) Successful in 6s
Lint / Deploy (pull_request) Skipped
Lint / Deploy (push) Skipped
Test / Python Tests (pytest) (push) Successful in 1m0s
Lint / Notify on failure (pull_request) Skipped
Security / Python Security (bandit) (pull_request) Successful in 2m7s
Test / Python Tests (pytest) (pull_request) Successful in 2m6s
/events lists every alert from the last 24 hours to 90 days, open or
cleared, with how long each lasted, failed checks and its ticket. Filters
(device, type, severity, state, range) live in the URL, so device pages
and tickets link straight to a device's history. A "Recurring" table
lists alerts that fired more than once on the same target. On phones the
rows become cards.

/api/events/history backs it (100 per page). The existing /api/events is
unchanged.

/health and the dashboard's monitor indicator now call the monitor
stalled after five missed polls (at least 10 minutes) instead of a fixed
20, and /health reports the monitor's age.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 20:29:09 -05:00
jared 9e2a2b987c Merge pull request 'Recovery notes and fuller context on tickets' (#20) from ticket-recovery-and-context into main
Lint / JS (eslint) (push) Successful in 30s
Lint / Python (flake8) (push) Successful in 1m17s
Lint / Notify on failure (push) Skipped
Security / Python Security (bandit) (push) Successful in 58s
Lint / Deploy (push) Successful in 4s
Test / Python Tests (pytest) (push) Successful in 1m18s
2026-11-10 20:09:03 -05:00
jaredandClaude Opus 5.5 437f7a415f Add recovery notes and fuller context to tickets
Lint / JS (eslint) (push) Successful in 7s
Lint / Python (flake8) (push) Successful in 1m26s
Lint / Notify on failure (push) Skipped
Security / Python Security (bandit) (push) Successful in 1m30s
Lint / Python (flake8) (pull_request) Successful in 52s
Lint / JS (eslint) (pull_request) Successful in 7s
Lint / Deploy (pull_request) Skipped
Lint / Deploy (push) Skipped
Test / Python Tests (pytest) (push) Successful in 1m4s
Lint / Notify on failure (pull_request) Skipped
Security / Python Security (bandit) (pull_request) Successful in 1m28s
Test / Python Tests (pytest) (pull_request) Successful in 2m0s
When an alert that opened a ticket clears, the monitor now comments on the
ticket (when it cleared, how long it lasted, failed checks, a link back).
It never closes or changes a ticket's status. Failed notes retry each
cycle for 24 hours; a 401/403 from Tinker stops them until restart.

Tickets are now Markdown with a "What to check" list and, where known:
the switch port the device plugs into (kept from the last time it was
seen, so a dead host still shows it), cutsheet cables and their path,
how often the alert fired in the last 7/30 days, other open alerts on the
device, and links into Gandalf (gandalf.public_url). Titles are unchanged
so Tinker's duplicate detection still works.

network_events gains recovery_notified, added at monitor startup; rows
that cleared before the upgrade count as already notified.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 19:44:50 -05:00
jared ff0094c8ff Merge pull request 'Cutsheet trace mode and mismatch alerts' (#19) from cutsheet-trace-and-alerts into main
Lint / JS (eslint) (push) Successful in 15s
Lint / Python (flake8) (push) Successful in 1m32s
Lint / Notify on failure (push) Skipped
Security / Python Security (bandit) (push) Successful in 1m12s
Lint / Deploy (push) Successful in 4s
Test / Python Tests (pytest) (push) Successful in 1m12s
2026-11-10 17:22:55 -05:00
jaredandClaude Opus 5.5 86aa29b378 Cutsheet trace mode and mismatch alerts
Lint / Python (flake8) (push) Successful in 1m8s
Security / Python Security (bandit) (push) Successful in 56s
Lint / Python (flake8) (pull_request) Successful in 50s
Lint / JS (eslint) (pull_request) Successful in 30s
Lint / Deploy (pull_request) Skipped
Lint / JS (eslint) (push) Successful in 16m17s
Lint / Notify on failure (push) Skipped
Test / Python Tests (pytest) (push) Successful in 43s
Lint / Notify on failure (pull_request) Skipped
Security / Python Security (bandit) (pull_request) Successful in 55s
Test / Python Tests (pytest) (pull_request) Successful in 50s
Lint / Deploy (push) Skipped
Trace a cord: pick a panel port, press Start, and unplug the cord at the
panel. The page polls a new admin-only endpoint that reads every switch
port's state from UniFi (cached 2 s), shows the one port that dropped
with a button to record the cable, and confirms when it's plugged back
in. Several ports dropping at once, or none within 3 minutes, is
explained rather than guessed at.

Mismatch alerts: the monitor runs the cutsheet check every poll. Each
mismatched installed run (wrong neighbor, no link, missing port, port
conflict) keeps one cable_mismatch event on its switch, resolved when
fixed, and opens a P4 ticket after cutsheet.mismatch_ticket_hours
(default 24, 0 never). Suppressing the switch or port stops the ticket.

Also fixes buttons with the hidden attribute still showing, which left a
Delete button on the new-cable form.

Closes #12

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 16:54:57 -05:00
jared cd602fdacf Merge pull request 'Add cutsheets: planned cabling checked against discovery' (#18) from cutsheets into main
Lint / JS (eslint) (push) Successful in 8s
Lint / Python (flake8) (push) Successful in 1m33s
Lint / Notify on failure (push) Skipped
Security / Python Security (bandit) (push) Successful in 1m37s
Lint / Deploy (push) Successful in 4s
Test / Python Tests (pytest) (push) Successful in 47s
2026-11-10 16:50:21 -05:00
jaredandClaude Opus 5.5 52cfea5439 Cutsheet: show the next free cable ID as a hint, not a placeholder
Lint / JS (eslint) (push) Successful in 7s
Lint / Python (flake8) (push) Successful in 48s
Lint / Notify on failure (push) Skipped
Lint / Python (flake8) (pull_request) Successful in 55s
Lint / JS (eslint) (pull_request) Successful in 14s
Lint / Deploy (pull_request) Skipped
Security / Python Security (bandit) (push) Successful in 1m22s
Lint / Deploy (push) Skipped
Lint / Notify on failure (pull_request) Skipped
Security / Python Security (bandit) (pull_request) Successful in 1m45s
Test / Python Tests (pytest) (pull_request) Successful in 1m6s
Test / Python Tests (pytest) (push) Successful in 1m0s
A placeholder of C01 in the empty ID field looked like a real value.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 16:10:51 -05:00
jaredandClaude Opus 5.5 b9412ff6ba Add cutsheets: planned cabling checked against discovery
Lint / JS (eslint) (push) Successful in 7s
Lint / Python (flake8) (push) Successful in 1m36s
Lint / Notify on failure (push) Skipped
Security / Python Security (bandit) (push) Successful in 1m40s
Lint / Python (flake8) (pull_request) Successful in 52s
Lint / JS (eslint) (pull_request) Successful in 7s
Lint / Deploy (pull_request) Skipped
Lint / Deploy (push) Skipped
Test / Python Tests (pytest) (push) Successful in 1m4s
Lint / Notify on failure (pull_request) Skipped
Security / Python Security (bandit) (pull_request) Successful in 1m13s
Test / Python Tests (pytest) (pull_request) Successful in 1m15s
A new Cutsheet page records where every cable is meant to go and compares
it with what Gandalf discovers.

- Inventory for what discovery can't see: patch panels, wall jacks,
  shelves and rack positions. Panels and jacks pass through front to rear.
- Cables with two endpoints, ID, type, length, color, status (planned,
  installed, dark, retired) and notes; the far end may be unterminated.
- Each cable's full run is traced through panels and jacks, and runs
  ending on a switch port are checked against its discovered neighbor
  (LLDP, client table, or a DAC serial seen at both ends): matches,
  wrong neighbor, no link, missing port, port conflict, unverified, idle.
- Undocumented links: live switch ports no cable mentions, one click to
  add with what Gandalf already knows. Port panels show the planned cable.
- Labels to make: cable IDs and panel-port labels not yet applied, with a
  print view, for a handheld label maker.
- CSV export, and all-or-nothing import that upserts by cable ID.
- Cables, panels and jacks appear in the dashboard search.

Editing needs the admin group and a JSON request body. Every change is
written to cutsheet_history in the same transaction. Tables are created
on first use.

Refs #12

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 16:05:08 -05:00
jared afc7aae580 Merge pull request 'Keep every switch port and show SFP modules' (#17) from switch-ports-and-sfp-modules into main
Lint / JS (eslint) (push) Successful in 7s
Lint / Python (flake8) (push) Successful in 2m2s
Security / Python Security (bandit) (push) Successful in 1m57s
Lint / Notify on failure (push) Skipped
Lint / Deploy (push) Successful in 9s
Test / Python Tests (pytest) (push) Successful in 52s
2026-11-10 14:44:49 -05:00
jaredandClaude Opus 5.5 7e588e5b02 Keep every switch port and show SFP modules
Security / Python Security (bandit) (push) Successful in 1m50s
Lint / Python (flake8) (pull_request) Successful in 1m20s
Lint / Python (flake8) (push) Successful in 1m16s
Lint / JS (eslint) (pull_request) Successful in 10s
Lint / JS (eslint) (push) Successful in 15s
Lint / Notify on failure (push) Skipped
Lint / Deploy (pull_request) Skipped
Test / Python Tests (pytest) (push) Successful in 1m52s
Lint / Deploy (push) Skipped
Lint / Notify on failure (pull_request) Skipped
Security / Python Security (bandit) (pull_request) Successful in 1m5s
Test / Python Tests (pytest) (pull_request) Successful in 1m7s
Ports were keyed by their UniFi name, so when two ports shared a name the
later one replaced the earlier. The 24-port switch lost port 13 this way
(ports 13 and 14 are both "Office TV"). A repeated name is now kept as
"<name> (Port N)".

Traffic rates are now matched to the previous poll by port number rather
than name. Names are re-read from UniFi every poll, so a port renamed
there keeps its rates instead of losing them for a cycle.

Collect what UniFi reports about each SFP cage: whether a module is
present, its type (DAC or optic), part, serial, fault flags, and DOM
readings when the module has them. The faceplate draws empty cages,
optics, DACs and unidentified modules differently and outlines a faulted
module in red. The port panel gets an SFP Module section. Both ends of a
DAC report the same cable serial, so each end links to the other.

Closes #7
Closes #8

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 14:37:08 -05:00
jared 085c488f7b Merge pull request 'Only trust Authelia identity headers from the proxy' (#16) from trusted-proxy-auth into main
Lint / JS (eslint) (push) Successful in 8s
Lint / Python (flake8) (push) Successful in 1m0s
Lint / Notify on failure (push) Skipped
Security / Python Security (bandit) (push) Successful in 54s
Lint / Deploy (push) Successful in 5s
Test / Python Tests (pytest) (push) Successful in 45s
2026-11-10 13:28:50 -05:00
jaredandClaude Opus 5.5 5c4e4dc099 Only trust Authelia identity headers from the proxy
Lint / JS (eslint) (push) Successful in 7s
Lint / Python (flake8) (push) Successful in 1m9s
Lint / Notify on failure (push) Skipped
Security / Python Security (bandit) (push) Successful in 1m33s
Lint / Python (flake8) (pull_request) Successful in 1m19s
Lint / JS (eslint) (pull_request) Successful in 7s
Lint / Deploy (pull_request) Skipped
Lint / Deploy (push) Skipped
Test / Python Tests (pytest) (push) Successful in 1m54s
Lint / Notify on failure (pull_request) Skipped
Security / Python Security (bandit) (pull_request) Successful in 1m16s
Test / Python Tests (pytest) (pull_request) Successful in 1m29s
Remote-User/Name/Email/Groups were read from every request, so a LAN host
connecting to the container directly could claim any user and group. Add
auth.trusted_proxies and ignore those headers unless the request came from
one of them: the X-Real-IP the local nginx sets, or the peer address when
gunicorn is reached directly. With nothing configured, nobody is trusted.
Rejected attempts are logged, and /api/avatar now uses the same check.

The container's nginx site blanks the same headers for non-NPM sources
(pve-infra 4e3ab7c).

Closes #3

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 13:23:24 -05:00
jared 93828b38e9 Merge pull request 'Give hosts longer before ticketing them as gone' (#15) from host-reboot-threshold into main
Lint / JS (eslint) (push) Successful in 11s
Lint / Python (flake8) (push) Successful in 56s
Lint / Notify on failure (push) Skipped
Security / Python Security (bandit) (push) Successful in 1m2s
Lint / Deploy (push) Successful in 5s
Test / Python Tests (pytest) (push) Successful in 1m14s
2026-11-06 19:41:44 -05:00
jaredandClaude Opus 5.5 178a03e898 Give hosts longer before ticketing them as gone
Lint / JS (eslint) (push) Successful in 16s
Lint / Python (flake8) (push) Successful in 1m23s
Lint / Notify on failure (push) Skipped
Security / Python Security (bandit) (push) Successful in 1m49s
Lint / Python (flake8) (pull_request) Successful in 54s
Lint / JS (eslint) (pull_request) Successful in 12s
Lint / Deploy (pull_request) Skipped
Lint / Deploy (push) Skipped
Test / Python Tests (pytest) (push) Successful in 1m35s
Lint / Notify on failure (pull_request) Skipped
Security / Python Security (bandit) (pull_request) Successful in 1m42s
Test / Python Tests (pytest) (pull_request) Successful in 2m3s
A host's node_exporter stops as soon as a shutdown begins and a normal
reboot takes about 3-5 minutes, so the 2-check failure_threshold cut a
ticket for planned reboots. Add monitor.host_failure_threshold, default 5,
for hosts with no metrics and ping-only hosts. Interface link-down alerts
keep the shorter threshold, and the dashboard still shows the host as down
straight away.

Closes #14

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-06 19:35:50 -05:00
jared 7c917969d8 Merge pull request 'Draw realistic front panels for every device model' (#13) from device-faceplates into main
Lint / JS (eslint) (push) Successful in 11s
Security / Python Security (bandit) (push) Successful in 1m20s
Lint / Python (flake8) (push) Successful in 1m31s
Lint / Notify on failure (push) Skipped
Lint / Deploy (push) Successful in 7s
Test / Python Tests (pytest) (push) Successful in 1m15s
2026-11-05 11:16:26 -05:00
jaredandClaude Opus 5.5 051e70b82b Draw realistic front panels for every device model
Lint / JS (eslint) (push) Successful in 10s
Lint / Python (flake8) (push) Successful in 57s
Lint / Notify on failure (push) Skipped
Security / Python Security (bandit) (push) Successful in 1m7s
Lint / Python (flake8) (pull_request) Successful in 59s
Lint / JS (eslint) (pull_request) Successful in 11s
Lint / Deploy (pull_request) Skipped
Lint / Deploy (push) Skipped
Test / Python Tests (pytest) (push) Successful in 1m22s
Lint / Notify on failure (pull_request) Skipped
Security / Python Security (bandit) (pull_request) Successful in 1m7s
Test / Python Tests (pytest) (pull_request) Successful in 1m28s
Replace the port blocks on device pages with SVG faceplates traced from
reference images: Dream Machine Pro, USW Pro 24 PoE, USW Aggregation,
USW Flex, USW Flex Mini, USP PDU Pro and UPS 2U Pro. Port LEDs use each
model's documented colors, and ports show a cable or module when up.

Remove SWITCH_LAYOUTS, which had wrong data: the aggregation switch was
numbered across the rows instead of odd over even, and the USW Flex had
an SFP cage it doesn't have. Models without a faceplate use plain blocks.

Show PDU and UPS outlets with on/off state and auto power-cycle, and let
the UPS page show its panel even though it reports no ports.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 11:11:48 -05:00
32 changed files with 7729 additions and 420 deletions

No files matched your search

+2 -2
View File
@@ -1,7 +1,7 @@
[flake8]
max-line-length = 120
# E221: multiple spaces before operator — intentional column alignment
# E305: two blank lines after function — relaxed for module-level code
# E221: multiple spaces before operator: intentional column alignment
# E305: two blank lines after function: relaxed for module-level code
extend-ignore = E221, E305
exclude = __pycache__, .git, node_modules
extend-exclude = node_modules
+1 -1
View File
@@ -50,7 +50,7 @@ jobs:
if [ -z "$MATRIX_WEBHOOK_URL" ] || [ "$MATRIX_WEBHOOK_URL" = "CONFIGURE_ME" ]; then exit 0; fi
curl -sf -X POST "$MATRIX_WEBHOOK_URL" \
-H "Content-Type: application/json" \
-d "{\"text\":\"CI FAILED: ${REPO} @ ${BRANCH} — ${RUN_URL}\"}"
-d "{\"text\":\"CI FAILED: ${REPO} @ ${BRANCH}: ${RUN_URL}\"}"
deploy:
name: Deploy
+223 -46
View File
@@ -9,7 +9,7 @@
Network monitoring dashboard for the LotusGuild Proxmox cluster.
Deployed on **LXC 157** (monitor-02 / 10.10.10.9), reachable at `gandalf.lotusguild.org`.
**Design System**: [web_template](https://code.lotusguild.org/LotusGuild/web_template) — shared CSS, JS, and layout patterns for all LotusGuild apps
**Design System**: [web_template](https://code.lotusguild.org/LotusGuild/web_template): shared CSS, JS, and layout patterns for all LotusGuild apps
![GANDALF walkthrough: dashboard, link debug with optical readings, switch inspector, and a one-click link diagnostic](docs/img/demo.gif)
@@ -51,11 +51,11 @@ A Proxmox/Ceph cluster lives or dies by its network, and network problems are sn
GANDALF uses the **LotusGuild Terminal Design System**. For all styling, component, and layout documentation see:
- [`web_template/README.md`](https://code.lotusguild.org/LotusGuild/web_template/src/branch/main/README.md) — full component reference, CSS variables, JS API
- [`web_template/base.css`](https://code.lotusguild.org/LotusGuild/web_template/src/branch/main/base.css) — unified CSS (`.lt-*` classes)
- [`web_template/base.js`](https://code.lotusguild.org/LotusGuild/web_template/src/branch/main/base.js) — `window.lt` utilities (toast, modal, auto-refresh, fetch helpers)
- [`web_template/python/base.html`](https://code.lotusguild.org/LotusGuild/web_template/src/branch/main/python/base.html) — Jinja2 base template
- [`web_template/python/auth.py`](https://code.lotusguild.org/LotusGuild/web_template/src/branch/main/python/auth.py) — `@require_auth` decorator pattern
- [`web_template/README.md`](https://code.lotusguild.org/LotusGuild/web_template/src/branch/main/README.md): full component reference, CSS variables, JS API
- [`web_template/base.css`](https://code.lotusguild.org/LotusGuild/web_template/src/branch/main/base.css): unified CSS (`.lt-*` classes)
- [`web_template/base.js`](https://code.lotusguild.org/LotusGuild/web_template/src/branch/main/base.js): `window.lt` utilities (toast, modal, auto-refresh, fetch helpers)
- [`web_template/python/base.html`](https://code.lotusguild.org/LotusGuild/web_template/src/branch/main/python/base.html): Jinja2 base template
- [`web_template/python/auth.py`](https://code.lotusguild.org/LotusGuild/web_template/src/branch/main/python/auth.py): `@require_auth` decorator pattern
---
@@ -82,7 +82,7 @@ Two processes share a MariaDB database:
|---|---|
| **Prometheus** (`10.10.10.48:9090`) | Physical NIC link state + traffic/error rates via `node_exporter` |
| **UniFi API** (`https://10.10.10.1`) | Switch port stats, device status, LLDP neighbor table, PoE data |
| **Pulse Worker** | SSH relay — runs `ethtool` + SFP DOM queries on each Proxmox host |
| **Pulse Worker** | SSH relay: runs `ethtool` + SFP DOM queries on each Proxmox host |
| **Ping** | Reachability for hosts without `node_exporter` (e.g. PBS) |
| **AT&T BGW320** (`http://192.168.1.254`) | Fiber light levels, PON and WAN state, WAN counters, scraped read-only from the gateway's status pages (no login) |
@@ -114,6 +114,58 @@ Ping-only (no node_exporter): **pbs** (10.10.10.3)
- Quick-suppress modal: apply timed or manual suppression from any alert row
- Auto-refreshes every 30 seconds via `/api/status` + `/api/network`
### Alert history (`/events`)
Every alert Gandalf raised in the last 24 hours to 90 days, including ones that cleared before anyone
saw them: when each started, how long it lasted, failed checks, and its ticket.
- Filter by device (name, port or interface), alert type, severity, and open or cleared. Filters are
kept in the URL, so `/events?target=large1&range=90d` is a shareable link; device pages and tickets
link to their own history this way.
- **Recurring** lists the same alert on the same target more than once in the range, worst first, since
a flapping cable or optic shows up here before anyone notices the tickets.
- API: `GET /api/events/history?range=24h|7d|30d|90d&type=&target=&severity=&status=all|active|resolved&offset=`
(100 per page).
### Rack (`/rack`)
The rack front, drawn from the rack units set on cutsheet items, top first.
- **Linking items to devices**: a cutsheet item can be named after the product ("UDM-Pro") and linked to
the live device with its **Gandalf device** field ("Dream Machine Pro"). Linked UniFi gear with a
faceplate is drawn with its real faceplate and live port state (the UPS 2U Pro shows its front only);
patch panels get a generic panel with each port's label; anything else is a labelled plate with its
live status. Cables may use either name: checks, suggestions, tickets and the device page treat an
item and its device as the same thing.
- **Drawn fronts**: gear without a live faceplate can pick a **Front drawing** on its cutsheet item:
UniFi NVR Pro (a full faceplate, `UNVRPRO` in `static/faceplates.js`, laid out from the CC0 NetBox
device library image), Sliger CX4712 4U (10 numbered bays), Rosewill RSV-L4500U 4U (perforated fan
door), the UniFi blank 24-port keystone patch panel (UACC-Rack-Panel-Patch-Blank-24: keystone jacks
appear where cables are documented), or a generic 1U/2U/4U server. The power light shows the linked device's live status. Case
drawings live in `static/fronts.js`.
- **Shelves**: an item can sit on a shelf item instead of having a rack unit. The shelf draws what is on
it side by side (mini PCs, desk switches), each with its status and a link to its page.
- **Front and rear**: each item is mounted from the front, the rear, or full depth (both sides). On a
4-post rack a front and a rear item can share a unit; a full-depth item (a server) takes it on both
sides, and the rear view shows its back. Items on a shelf take the shelf's side. The Front / Rear switch
flips the drawing (`?face=rear`).
- **Racks**: admins name a rack and set its height with **Rack settings** on the page, and add more with
**+ Rack** (a tab per rack). Renaming a rack moves its items; an empty rack can be deleted. Each item
has a rack (empty means the first). Until a rack is saved, racks come from config:
`racks: [{"name": "Main", "units": 42}, ...]`, or one rack `rack.name` (default "Rack 1") with
`rack.units` (default 42); saving the first one carries its items over.
- Every documented port shows its cutsheet state (green matches, red mismatch, grey unconfirmed).
Hovering a port lights up every port on the same cable run, through patch panels, and names the
cables; clicking opens the switch port or the cable.
- Runs of 3 or more empty units fold into one band; "Show empty units" draws them in full (remembered
per browser). Every device is drawn at the full 19" width.
- **Download SVG / PNG** saves the current rack on a white page for printing or planning.
- Items that would overlap another or run past the top of the rack are listed, not drawn over. Where two
claim the same top unit, the one recorded first is drawn. Items without a rack unit are listed below.
- The rack keeps its own dark "hardware" palette in both themes.
### Health check (`/health`)
No login needed. Returns 200 when the database answers and the monitor has completed a check recently,
otherwise 503 with the failing check: `{"status": "degraded", "checks": {"db": "ok", "monitor": "stale",
"monitor_age_s": 742}}`. The monitor counts as stalled after five missed polls (at least 10 minutes),
so point an uptime monitor at it to catch a hung `gandalf-monitor`, not just a dead web app.
### Device pages (`/device/<name>`)
One page per host, switch, router, AP, PDU, or modem. Reach them from the search box on the
dashboard (`/` focuses it), or from any device name. Search matches hostname, IP, MAC, model, type,
@@ -136,8 +188,25 @@ sees but `config.json` doesn't list still get a page, with their state shown as
they aren't alerted on.
### Port inspector (on switch and router device pages)
A model-accurate front panel, drawn from the layout config in `static/port-inspector.js`
(`SWITCH_LAYOUTS`). `/inspector` now redirects to the dashboard. Link to a port with `/device/<name>#port-<n>`.
A realistic front panel, drawn as SVG from the model's real geometry in `static/faceplates.js`
(`FACEPLATES`). `/inspector` now redirects to the dashboard. Link to a port with `/device/<name>#port-<n>`.
**SFP cages** show what UniFi reports is in them: empty, a fibre optic (two LC sockets), a DAC (cable
boot), or an unidentified module. A module raising a receive or transmit fault is outlined in red.
The port panel's **SFP Module** section lists type, part, serial and faults, plus the module's
optical readings (TX/RX power, temperature, voltage, bias) when it reports them. Copper DACs don't.
Both ends of a DAC report the same cable serial, so a DAC seen on two ports links to its other end.
**Cutsheet marks**: a port with a cable documented in the cutsheet gets a dot in its corner: green when
it matches what Gandalf sees, red for a mismatch (wrong neighbor, no link, missing port, port conflict),
grey when it is documented but can't be confirmed (planned, dark, through a panel, or the far end isn't
visible). Hovering the port names the cable. "Cutsheet marks" in the legend hides them; the choice is
remembered in the browser.
**Inventory link**: the device page's 📦 button opens the device's record in the inventory
(`inventory.base_url`). Admins set it with ✎ by pasting the record's URL; only URLs on the inventory
host are accepted. Until one is set, the button searches the inventory for the model. Tickets include
the link too.
**Port block colours:**
| Colour | State |
@@ -168,19 +237,53 @@ neighbors that can't be matched show their MAC. Bonded NICs share a MAC, so only
2. The Pulse worker can SSH to the server
3. Optional: `lldpd` on the server lets diagnostics confirm the cabling from the server's side
**Supported switch models** (set `SWITCH_LAYOUTS` keys to your UniFi model codes):
**Supported models** (keys are UniFi model codes):
| Key | Model | Layout |
| Key | Model | Front panel |
|---|---|---|
| `USF5P` | UniFi Switch Flex 5 PoE | 4×RJ45 + 1×SFP uplink |
| `USL8A` | UniFi Switch Lite 8 PoE | 8×SFP (2 rows of 4) |
| `US24PRO` | UniFi Switch Pro 24 | 24×RJ45 staggered + 2×SFP |
| `USPPDUP` | Custom/other | Single-port fallback |
| `UDMPRO` | Dream Machine Pro | 9×RJ45 + 2×SFP+ |
| `USMINI` | UniFi Switch Mini | 5-port row |
| `UDMPRO` | Dream Machine Pro | 8×RJ45 LAN, RJ45 WAN, SFP+ WAN, SFP+ LAN, screen, drive bay |
| `US24PRO` | USW Pro 24 PoE | 24×RJ45 in two blocks of 12, 2×SFP+ |
| `USL8A` | USW Aggregation | 8×SFP+ in four stacked pairs |
| `USF5P` | USW Flex | 5×RJ45, PoE in on port 1, PoE out on 2-5 |
| `USMINI` | USW Flex Mini | 5×RJ45, PoE in on port 1 |
| `USPPDUP` | USP PDU Pro | 20 outlets (4 USB-C, 16 AC), management port 21, surge pass-through ports 22-23 |
| `USPDA2B` | UPS 2U Pro | Front with touchscreen outlet tiles; rear with 8 outlets, EPO, surge and MGMT ports |
Add new layouts by adding a key to `SWITCH_LAYOUTS` matching the `model` field
returned by the UniFi API for that device.
Port LEDs use the colors from each model's quick start guide. Other models use plain blocks until they get an
entry in `FACEPLATES`.
### Cutsheet (`/cutsheet`)
Where every cable is meant to go, checked against what Gandalf actually sees. Anyone who can log in
can view it; only the `admin` group can edit, and every change is logged with who made it and when.
- **Inventory**: things discovery can't see: patch panels, wall jacks, shelves, and rack positions
for devices (use a device's exact Gandalf name). Panels and jacks are passive: a cable on a
port's front continues through the same port's rear.
- **Cables**: two endpoints each (device or item, port, and front/rear for panels and jacks), plus
ID, type, length, color, status (`planned`, `installed`, `dark`, `retired`) and notes. Leave the
far end blank for a run that ends nowhere yet, such as an unterminated fibre.
- **Paths**: each cable shows its full run through any panels and jacks, e.g. switch port 13 →
panel port 5 → bedroom jack.
- **Plan vs. actual**: each installed run ending on a switch or router port is compared with that
port's discovered neighbor (LLDP, the UniFi client table, or a DAC's serial reported at both
ends): *matches*, *wrong neighbor*, *no link*, *missing port*, or *port conflict* (two installed
cables in one port). Runs that end at a jack are *unverified* while linked and *idle* when not.
Planned, dark and retired cables aren't checked.
- **Undocumented links**: live switch ports no cable mentions, with an Add button that pre-fills
what Gandalf knows. Each switch port panel also shows its planned cable, or links to add one.
- **Labels to make**: cable IDs (one per cord end) and panel-port labels not yet stuck on, sized for
typing on a handheld label maker. Tick each off once it's applied; **Print list** prints just this.
- **CSV**: export, and import that adds or updates cables by ID. A file with any invalid row imports
nothing.
- Cables, panels and jacks are included in the dashboard search.
- **Trace a cord** (admins): pick a panel port and press Start, then unplug that cord at the panel.
Gandalf reads every switch port's state from UniFi every 3 seconds and shows the one that drops,
with a button to record the cable, then confirms when it's plugged back in. The device on that
port loses its link for those seconds. A cord whose far end has nothing linked can't be traced
this way.
- **Mismatch alerts**: the monitor runs the same check every poll. A mismatched run opens a
`cable_mismatch` event on the switch straight away and resolves it once fixed; it becomes a P4
ticket only after `cutsheet.mismatch_ticket_hours`.
### Suppressions (`/suppressions`)
- Create timed (30 min / 1 hr / 4 hr / 8 hr) or manual suppressions
@@ -199,8 +302,8 @@ returned by the UniFi API for that device.
|---|---|
| UniFi device offline (≥`unifi_failure_threshold` consecutive checks) | P2 High |
| Proxmox host NIC link-down regression (≥2 consecutive checks) | P2 High |
| Host unreachable via ping (≥2 consecutive checks) | P2 High |
| Configured host has no metrics in Prometheus (host or `node_exporter` down, ≥2 consecutive checks) | P2 High |
| Host unreachable via ping (≥`host_failure_threshold` consecutive checks) | P2 High |
| Configured host has no metrics in Prometheus (host or `node_exporter` down, ≥`host_failure_threshold` consecutive checks) | P2 High |
| Prometheus unavailable, so host and interface alerting is paused (≥2 consecutive checks) | P2 High |
| ≥3 hosts simultaneously reporting interface or metrics failures | P1 Critical |
| WAN down: broadband or optical status not Up, or PON not in O5 (≥`modem.failure_threshold`) | P1 Critical |
@@ -211,9 +314,38 @@ returned by the UniFi API for that device.
| Modem pages unreadable, e.g. after a firmware update (≥`modem.failure_threshold`) | P3 |
| UniFi logs that Smart Power auto power-cycled the modem | P3 |
| UniFi logs that the WAN failed multiple times in 24 hours (at most one ticket a day) | P2 |
| An installed cable doesn't match the cutsheet (wrong neighbor, no link, missing port, port conflict) for `cutsheet.mismatch_ticket_hours` | P4 |
A failed Pulse ping check counts as "unknown": it neither raises nor resolves `host_unreachable`.
### What a ticket contains
Tickets are Markdown. Besides the alert's own facts and a numbered "What to check" list, each one adds
whatever Gandalf knows around the problem:
- **Where it is connected**: the switch port(s) the host or device plugs into, with link state, speed,
PoE and SFP module, linked to that port on the switch's page. A host that has dropped off the network
has lost its LLDP entry, so Gandalf keeps the last port it saw each device on (`known_uplinks` in
`monitor_state`) and shows that, marked "last seen linked there".
- The **cutsheet** cables ending on the device or port, with their full path through patch panels
- **History**: how often the same alert fired in the last 7 and 30 days, and when it last cleared;
3 or more in a week is called out as recurring
- **Other active alerts** on the same device, with their ticket numbers
- **Links** to the device in Gandalf (from `gandalf.public_url`)
Titles keep the `[target][auto][production]...` tag format, which Tinker uses to spot duplicates.
### Recovery notes
When an alert that opened a ticket clears, the monitor adds a comment to that ticket: when it cleared, how
long it lasted, how many checks failed, and a link back to Gandalf. **Gandalf never closes or changes the
status of a ticket**; that is left to a person. The one-shot WAN reports (modem power-cycled, WAN unstable)
get no note, since they describe something already over.
A note that fails to post is retried every cycle for 24 hours. Posting needs a Tinker API key with
`read_write` scope; if Tinker answers 401 or 403, the monitor logs one error and stops trying until it is
restarted.
### WAN modem notes
The alarm and warning limits are read from the gateway on every poll, so they are never hard-coded here.
@@ -243,7 +375,7 @@ generate tickets. Baseline is stored in MariaDB and survives daemon restarts.
| `all` | Everything (global maintenance mode) |
Suppressions can be manual (persist until removed) or timed (auto-expire).
Expired suppressions are checked at evaluation time — no background cleanup needed.
Expired suppressions are checked at evaluation time: no background cleanup needed.
---
@@ -269,9 +401,12 @@ Shared by both processes. Located in the working directory (`/var/www/html/prod/
"site_id": "default"
},
"ticket_api": {
"url": "https://t.lotusguild.org/api/tickets",
"url": "https://t.lotusguild.org/create_ticket_api.php",
"api_key": "..."
},
"gandalf": {
"public_url": "https://gandalf.lotusguild.org"
},
"pulse": {
"url": "http://<pulse-host>:<port>",
"api_key": "...",
@@ -279,7 +414,8 @@ Shared by both processes. Located in the working directory (`/var/www/html/prod/
"timeout": 45
},
"auth": {
"allowed_groups": ["admin"]
"allowed_groups": ["admin"],
"trusted_proxies": ["10.10.10.27"]
},
"hosts": [
{ "name": "large1", "prometheus_instance": "10.10.10.2:9100" },
@@ -292,12 +428,16 @@ Shared by both processes. Located in the working directory (`/var/www/html/prod/
"monitor": {
"poll_interval": 120,
"failure_threshold": 2,
"host_failure_threshold": 5,
"unifi_failure_threshold": 5,
"cluster_threshold": 3,
"ping_hosts": [
{ "name": "pbs", "ip": "10.10.10.3" }
]
},
"cutsheet": {
"mismatch_ticket_hours": 24
},
"modem": {
"url": "http://192.168.1.254",
"name": "att-modem"
@@ -314,17 +454,27 @@ Shared by both processes. Located in the working directory (`/var/www/html/prod/
| `unifi.controller` | UniFi controller base URL (HTTPS, self-signed cert ignored) |
| `unifi.api_key` | UniFi API key from controller Settings → API |
| `unifi.site_id` | UniFi site ID (default: `default`) |
| `ticket_api.api_key` | Tinker Tickets bearer token |
| `ticket_api.url` | Tinker Tickets `create_ticket_api.php` URL |
| `ticket_api.api_key` | Tinker Tickets bearer token. Needs `read_write` scope to add recovery notes |
| `ticket_api.comment_url` | Tinker comment endpoint (default: `api/ticket_comment_api.php` beside `ticket_api.url`) |
| `gandalf.public_url` | Gandalf's own address, for links in tickets (default: `https://gandalf.lotusguild.org`) |
| `rack.units`, `rack.name` | The single rack's height and name on `/rack` (defaults: 42, "Rack 1") |
| `racks` | Several racks: `[{"name": "...", "units": 42}, ...]`, in tab order; overrides `rack` |
| `inventory.base_url` | Asset inventory (HomeBox) address; device inventory links must be on this host (default: `https://inventory.lotusguild.org`) |
| `inventory.search_url` | Search link used before a device has a record linked, with `{base}` and `{q}` placeholders (default: `{base}/items?q={q}`) |
| `pulse.url` | Pulse worker API base URL (for SSH relay) |
| `pulse.worker_id` | Which Pulse worker runs ethtool collection |
| `pulse.timeout` | Max seconds to wait for SSH collection per host |
| `auth.allowed_groups` | Authelia groups that may access Gandalf |
| `auth.trusted_proxies` | Addresses or CIDR ranges of the proxy that runs Authelia forward auth (NPM). Gandalf only trusts the `Remote-*` identity headers on requests from these sources, since anyone else could set them. **Required**: with no entries, every request is unauthenticated. |
| `hosts` | Maps Prometheus instance labels → display hostnames |
| `monitor.poll_interval` | Seconds between full check cycles (default: 120) |
| `monitor.failure_threshold` | Consecutive failures before creating ticket (default: 2) |
| `monitor.unifi_failure_threshold` | Consecutive failures before ticketing a UniFi device as offline (default: same as `failure_threshold`). Set higher than `failure_threshold` — UniFi switches/APs can take several minutes to rejoin after a firmware-update reboot, so a low threshold cuts tickets for momentary maintenance reboots instead of real failures. |
| `monitor.host_failure_threshold` | Consecutive failures before ticketing a host that has disappeared, whether it has no metrics or doesn't answer ping (default: 5). A normal reboot takes about 3-5 minutes, so the default rides it out: the host still shows as down on the dashboard, but a ticket opens only after about 8 minutes at the default poll interval. For longer maintenance, suppress the host first. |
| `monitor.unifi_failure_threshold` | Consecutive failures before ticketing a UniFi device as offline (default: same as `failure_threshold`). Set higher than `failure_threshold`: UniFi switches/APs can take several minutes to rejoin after a firmware-update reboot, so a low threshold cuts tickets for momentary maintenance reboots instead of real failures. |
| `monitor.cluster_threshold` | Hosts with failures to trigger cluster-wide P1 (default: 3) |
| `monitor.ping_hosts` | Hosts checked only by ping (no node_exporter) |
| `cutsheet.mismatch_ticket_hours` | Hours a cutsheet mismatch must last before it opens a P4 ticket (default: 24; `0` never tickets). The mismatch shows on the dashboard and the switch's page straight away, so recabling never pages anyone. Suppressing the switch or its port also stops the ticket. |
| `modem.url` | AT&T gateway base URL. Omit the `modem` block to disable modem monitoring. Must be reachable from the monitor host. |
| `modem.name` | Name used for the modem's alerts, tickets, and suppressions (default: `att-modem`) |
| `modem.timeout` | Seconds to wait per status page (default: 10) |
@@ -336,7 +486,7 @@ Shared by both processes. Located in the working directory (`/var/www/html/prod/
## Deployment (LXC 157)
### 1. Database — MariaDB LXC 149 (`10.10.10.50`)
### 1. Database: MariaDB LXC 149 (`10.10.10.50`)
```sql
CREATE DATABASE gandalf CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
@@ -350,7 +500,7 @@ Import schema:
mysql -h 10.10.10.50 -u gandalf -p gandalf < schema.sql
```
### 2. LXC 157 — Install dependencies
### 2. LXC 157: Install dependencies
```bash
pip3 install -r requirements.txt
@@ -423,7 +573,7 @@ systemctl restart authelia
### 6. NPM reverse proxy
- **Domain:** `gandalf.lotusguild.org`
- **Forward to:** `http://10.10.10.61:8000` (gunicorn direct, no nginx needed on LXC)
- **Forward to:** `http://10.10.10.61:80` (the local nginx, which forwards to gunicorn on `127.0.0.1:8000`)
- **Forward Auth:** Authelia at `http://10.10.10.167:9091`
- **WebSockets:** Not required
@@ -480,9 +630,9 @@ after `ldap.cache_ttl` seconds or can be removed from `ldap.cache_dir`.
- Hosts missing from `config.json` are named by IP, so their ports may not match what you expect
### Port inspector: front panel shows as a flat list (no layout)
- The switch's `model` field from UniFi doesn't match any key in `SWITCH_LAYOUTS` in `port-inspector.js`
- The switch's `model` field from UniFi doesn't match any key in `FACEPLATES` in `faceplates.js`
- The model is shown on the device page
- Add the model key to `SWITCH_LAYOUTS` in `port-inspector.js` with the correct row/SFP layout
- Add the model to `FACEPLATES` in `faceplates.js` (see Adding a New Device Faceplate)
### Baseline re-initializing on every restart
- `interface_baseline` is stored in the `monitor_state` DB table; survives restarts
@@ -517,6 +667,8 @@ gandalf/
├── monitor.py # Background daemon (Prometheus, UniFi, Pulse, alert logic)
├── modem.py # Read-only AT&T gateway status page client and parser
├── devices.py # Device inventory for search and device pages
├── cutsheet.py # Cutsheet validation, path tracing, plan-vs-actual checks, CSV
├── ticket_text.py # Markdown for tickets and recovery notes
├── db.py # Database operations (MariaDB via pymysql, thread-local conn reuse)
├── schema.sql # Database schema (network_events, suppression_rules, monitor_state)
├── config.json # Runtime configuration (not committed with secrets)
@@ -525,11 +677,18 @@ gandalf/
│ ├── style.css # Terminal aesthetic CSS (CRT scanlines, green-on-black)
│ ├── app.js # Dashboard JS (auto-refresh, events, suppress modal, search, modem panel)
│ ├── device.js # Device page rendering
│ ├── cutsheet.js # Cutsheet page
│ ├── events.js # Alert history page
│ ├── rack.js # Rack drawing
│ ├── fronts.js # Drawn fronts for gear without a live faceplate (NVR, server cases)
│ └── port-inspector.js # Switch front panel, port panel, path check, diagnostics
└── templates/
├── base.html # Shared layout (header, nav, footer)
├── index.html # Dashboard page
├── device.html # Per-device page
├── cutsheet.html # Cutsheet page and its editors
├── events.html # Alert history page
├── rack.html # Rack drawing
├── _modem_panel.html # WAN / Fiber panel, shared by the dashboard and modem page
└── suppressions.html # Suppression management page
```
@@ -545,27 +704,39 @@ gandalf/
4. Restart monitor: `systemctl restart gandalf-monitor`
5. For SFP DOM / ethtool: ensure the host is SSH-accessible from the Pulse worker
### Adding a New Switch Layout
### Adding a New Device Faceplate
Find the UniFi model code for the switch (shown on its device page), then add to `SWITCH_LAYOUTS` in
`static/port-inspector.js`:
Find the UniFi model code on the device page, then add an entry to `FACEPLATES` in `static/faceplates.js`.
Trace coordinates from a front-on image of the device, using the image's pixels as the `viewBox`:
```javascript
'MYNEWMODEL': {
rows: [[1,2,3,4,5,6,7,8], [9,10,11,12,13,14,15,16]], // port_idx by row
sfp_section: [17, 18], // separate SFP cage ports (rendered below rows)
sfp_ports: [], // port_idx values that are SFP-type within rows
width: 1100, height: 110, frameClass: 'fp-scroll', scrollX: 500,
label: 'My New Switch',
legend: [['off', 'no link'], ['amber', '10/100M'], ['green', '1G']],
roles: { 1: 'RJ45' },
ports: rj45Pairs([520, 557, 594], { top: 38, bottom: 69, topLabel: 15.5, bottomLabel: 98 }),
decor() { return fpVents([[90, 500]], 3) + fpQuadScreen(15, 23, 60); },
},
```
Take LED colors from the model's quick start guide. See the comment at the top of the file for every option.
### Database Schema Notes
- `network_events`: one row per active event; `resolved_at` is set when recovered
- `cutsheet_items` gained `rack`, `shelf`, `device`, `mount` and `chassis` columns; they are added automatically on first use
- `cutsheet_racks`: racks saved on the rack page (name, height, notes)
- `device_links`: each device's inventory URL, by device name; created with the cutsheet tables
- `network_events`: one row per active event; `resolved_at` is set when recovered, and
`recovery_notified` once the recovery note is on its ticket (column added automatically at monitor startup)
- `suppression_rules`: `active=FALSE` when removed; `expires_at` checked at query time
- `monitor_state`: key/value store; `interface_baseline`, `link_stats`, and `modem_stats` are JSON blobs
- `monitor_state` also holds `wan_history` (WAN outages, modem restarts) and `unifi_log_cursor` (how far the UniFi log has been read)
- Database sessions run in UTC (`db.py`), whatever the server's time zone
- `modem_samples`: optical readings per poll, kept 90 days; created automatically at monitor startup
- `cutsheet_items`, `cutsheet_cables`, `cutsheet_port_labels`, `cutsheet_history`: cutsheet records and
their change log, created automatically on first use. Cables refer to devices and items by name; renaming
an item updates its cables, but a device renamed in UniFi needs its cables edited to match
### Security Notes
@@ -576,20 +747,26 @@ Find the UniFi model code for the switch (shown on its device page), then add to
- **Interface name validation**: `monitor.py` validates SSH interface names against
`^[a-zA-Z0-9_.@-]+$` before use, and additionally wraps them with `shlex.quote()`
for defense-in-depth.
- **DB parameters**: all SQL uses parameterised queries via pymysql — no string
- **DB parameters**: all SQL uses parameterised queries via pymysql: no string
concatenation into SQL.
- **Auth**: Authelia enforces admin-only access at the nginx/LXC 167 layer; the Flask
app additionally checks the `Remote-User` header via `@require_auth`.
- **Auth**: Authelia enforces admin-only access at the NPM/LXC 167 layer; the Flask
app additionally checks the `Remote-User` and `Remote-Groups` headers via `@require_auth`.
Those headers are only real when NPM sent the request, because its forward auth
overwrites them, so a LAN host connecting to the container directly could otherwise
claim any identity. Two layers stop that. The container's nginx site (tracked in
pve-infra) blanks them unless the request came from NPM. The app also ignores them
unless the source address (nginx's `X-Real-IP`, or the peer address when gunicorn is
reached directly) is in `auth.trusted_proxies`, and it fails closed when that is unset.
### Known Limitations
- Single gunicorn worker (`--workers 1`) — required because `db.py` uses thread-local
- Single gunicorn worker (`--workers 1`): required because `db.py` uses thread-local
connection reuse (one connection per thread). Multiple workers would each have their
own connection, which is fine, but the thread-local optimisation only helps within
one worker.
- No CSRF tokens on API endpoints — mitigated by Authelia session cookies being
- No CSRF tokens on API endpoints: mitigated by Authelia session cookies being
`SameSite=Strict` and the site being admin-only.
- SSH collection via Pulse is synchronous — if Pulse is slow, the entire monitor cycle
- SSH collection via Pulse is synchronous: if Pulse is slow, the entire monitor cycle
is delayed. The `pulse.timeout` config controls the max wait.
- UniFi LLDP data is only as fresh as the last monitor poll (120s default).
@@ -601,11 +778,11 @@ Find the UniFi model code for the switch (shown on its device page), then add to
|---|---|---|
| `lint.yml` (python-lint) | flake8 on all `.py` files | Every push and PR |
| `lint.yml` (js-lint) | ESLint on `static/` | Every push and PR |
| `test.yml` | pytest — `diagnose.py`, `modem.py`, and `monitor.py` alert logic | Every push and PR |
| `test.yml` | pytest: `diagnose.py`, `modem.py`, and `monitor.py` alert logic | Every push and PR |
| `security.yml` | bandit `-ll` (medium+ severity) | Every push, PR, and weekly Monday 6am |
| `deploy` job in `lint.yml` | Calls the `gandalf-deploy` webhook on CT157 (10.10.10.61) | Push to `main` only, after both lint jobs pass |
Branch protection is enabled on `main` — both lint jobs must pass before any PR can merge.
Branch protection is enabled on `main`: both lint jobs must pass before any PR can merge.
Tests live in `tests/`:
- `test_diagnose.py`: `DiagnosticsRunner` static methods (`build_ssh_command`, `parse_output`,
+682 -31
View File
@@ -1,4 +1,4 @@
"""Gandalf – Global Advanced Network Detection And Link Facilitator.
"""Gandalf: Global Advanced Network Detection And Link Facilitator.
Flask web application serving the monitoring dashboard and suppression
management UI. Authentication via Authelia forward-auth headers.
@@ -17,13 +17,16 @@ import time
import uuid
from datetime import datetime, timezone
from functools import wraps
from typing import Optional
from urllib.parse import quote, urlparse
from flask import Flask, jsonify, make_response, redirect, render_template, request, send_file, url_for
import cutsheet
import db
import devices
import diagnose
from monitor import PulseClient
from monitor import PulseClient, UnifiClient
logging.basicConfig(
level=logging.INFO,
@@ -60,7 +63,7 @@ def inject_config():
# In-memory diagnostic job store { job_id: { status, result, created_at } }
_diag_jobs: dict = {}
_diag_lock = threading.Lock()
# Per-user rate-limit: { username: [epoch_float, ...] } — cleaned inside _diag_lock
# Per-user rate-limit: { username: [epoch_float, ...] }: cleaned inside _diag_lock
_diag_rate: dict = {}
@@ -77,7 +80,7 @@ def _purge_old_jobs_loop():
for jid, j in list(_diag_jobs.items()):
if j['status'] == 'running' and j.get('created_at', 0) < stuck_cutoff:
j['status'] = 'done'
j['result'] = {'status': 'error', 'error': 'Diagnostic abandoned — no activity for 5 minutes.'}
j['result'] = {'status': 'error', 'error': 'Diagnostic abandoned: no activity for 5 minutes.'}
logger.error(f'Diagnostic job {jid} stuck (no activity for 5 min); marked done/error')
@@ -103,22 +106,78 @@ def add_security_headers(response):
return response
def _daemon_ok(last_check: str) -> bool:
"""Return True if monitor last checked within 20 minutes."""
def _monitor_stale_after() -> int:
"""Seconds without a completed check before the monitor counts as stalled.
Five missed polls, and never under 10 minutes: one slow cycle (an SSH timeout
to a dead host) shouldn't trip it, but a hung monitor is caught in minutes.
"""
try:
poll = int(_config().get('monitor', {}).get('poll_interval', 120))
except (TypeError, ValueError):
poll = 120
return max(600, poll * 5)
def _monitor_age(last_check: str) -> Optional[float]:
"""Seconds since the monitor's last check, or None if it never ran or can't be read."""
if not last_check or last_check == 'Never':
return False
return None
try:
ts = datetime.strptime(last_check, '%Y-%m-%d %H:%M:%S UTC').replace(tzinfo=timezone.utc)
return (datetime.now(timezone.utc) - ts).total_seconds() < 1200
except Exception:
return False
except ValueError:
return None
return (datetime.now(timezone.utc) - ts).total_seconds()
def _daemon_ok(last_check: str) -> bool:
"""True if the monitor checked recently enough (see _monitor_stale_after)."""
age = _monitor_age(last_check)
return age is not None and age < _monitor_stale_after()
# ---------------------------------------------------------------------------
# Auth helpers
# ---------------------------------------------------------------------------
def _request_source() -> str:
"""The address the request came from.
Gunicorn listens on loopback behind the local nginx, which overwrites X-Real-IP
with the real peer address. A peer that isn't loopback reached gunicorn directly,
so its own address is the source and any X-Real-IP it sent is ignored.
"""
peer = request.remote_addr or ''
try:
if ipaddress.ip_address(peer).is_loopback:
return request.headers.get('X-Real-IP', '').strip()
except ValueError:
return ''
return peer
def _from_trusted_proxy() -> bool:
"""True when the request came through the Authelia-protected proxy.
Only then are the Remote-* identity headers real: anyone else on the LAN could
set them. Fails closed: with no auth.trusted_proxies configured, nobody is trusted.
"""
try:
source = ipaddress.ip_address(_request_source())
except ValueError:
return False
for entry in _config().get('auth', {}).get('trusted_proxies', []):
try:
if source in ipaddress.ip_network(entry, strict=False):
return True
except ValueError:
logger.error(f'Ignoring invalid auth.trusted_proxies entry {entry!r}')
return False
def _get_user() -> dict:
if not _from_trusted_proxy():
return {'username': '', 'name': '', 'email': '', 'groups': []}
return {
'username': request.headers.get('Remote-User', ''),
'name': request.headers.get('Remote-Name', ''),
@@ -136,8 +195,13 @@ def require_auth(f):
def wrapper(*args, **kwargs):
user = _get_user()
if not user['username']:
if request.headers.get('Remote-User'):
logger.warning(
f'Ignored identity headers from untrusted source {_request_source() or "unknown"!r}; '
f'only auth.trusted_proxies may send them'
)
return (
'<h1>401 – Not authenticated</h1>'
'<h1>401: Not authenticated</h1>'
'<p>Please access Gandalf through '
'<a href="https://auth.lotusguild.org">auth.lotusguild.org</a>.</p>',
401,
@@ -147,7 +211,7 @@ def require_auth(f):
safe_user = html.escape(user['username'])
safe_groups = html.escape(', '.join(allowed))
return (
f'<h1>403 – Access denied</h1>'
f'<h1>403: Access denied</h1>'
f'<p>Your account ({safe_user}) is not in an allowed group '
f'({safe_groups}).</p>',
403,
@@ -255,7 +319,8 @@ def links_page():
@app.route('/device/<path:name>')
@require_auth
def device_page(name: str):
return render_template('device.html', user=_get_user(), device_name=name)
user = _get_user()
return render_template('device.html', user=user, device_name=name, can_edit='admin' in user['groups'])
@app.route('/inspector')
@@ -265,6 +330,50 @@ def inspector():
return redirect(url_for('index'))
@app.route('/events')
@require_auth
def events_page():
return render_template('events.html', user=_get_user())
_HISTORY_RANGES = {'24h': 24, '7d': 24 * 7, '30d': 24 * 30, '90d': 24 * 90}
_HISTORY_PAGE = 100
@app.route('/api/events/history')
@require_auth
def api_events_history():
"""Every alert open at some point in a time window, with summaries.
Query: range (24h|7d|30d|90d), type, target (substring of name or detail),
severity, status (all|active|resolved), offset.
"""
args = request.args
hours = _HISTORY_RANGES.get(args.get('range', '7d'))
if hours is None:
return jsonify({'error': f'range must be one of {", ".join(_HISTORY_RANGES)}'}), 400
severity = args.get('severity', '')
if severity not in ('', 'critical', 'warning', 'info'):
return jsonify({'error': 'severity must be critical, warning or info'}), 400
status = args.get('status', 'all')
if status not in ('all', 'active', 'resolved'):
return jsonify({'error': 'status must be all, active or resolved'}), 400
try:
offset = max(int(args.get('offset', 0)), 0)
except ValueError:
return jsonify({'error': 'offset must be an integer'}), 400
event_type = args.get('type', '')[:60]
target = args.get('target', '').strip()[:255]
result = db.get_events_history(hours, event_type, target, severity, status,
limit=_HISTORY_PAGE, offset=offset)
result['flappers'] = db.get_flappers(hours, event_type, target, severity)
result['types'] = db.get_event_types()
result['offset'] = offset
result['page_size'] = _HISTORY_PAGE
return jsonify(result)
@app.route('/suppressions')
@require_auth
@require_admin
@@ -367,10 +476,38 @@ def api_modem():
@app.route('/api/devices')
@require_auth
def api_devices():
"""Device list for the home page search."""
return jsonify({'devices': devices.build_index(
"""Device list for the home page search, plus cutsheet panels, jacks and cables."""
found = devices.build_index(
_state_json('network_snapshot'), _state_json('link_stats'), _state_json('modem_stats'),
)})
)
known = {d['name'] for d in found}
try:
_ensure_cutsheet_schema()
data = db.cutsheet_load()
except Exception as e:
logger.error(f'Cutsheet unavailable for search: {e}')
data = {'items': [], 'cables': []}
for item in data['items']:
if item['name'] in known:
continue
kind = item['kind'].replace('_', ' ')
found.append({
'name': item['name'], 'kind': kind, 'status': 'unknown', 'ip': '', 'mac': '', 'model': '',
'url': f'/cutsheet#item-{item["id"]}', 'interface_count': item.get('port_count') or 0,
'search': ' '.join(filter(None, [item['name'], kind, item.get('location'), 'cutsheet'])).lower(),
})
for cable in data['cables']:
if not cable.get('label'):
continue
ends = ' '.join(filter(None, [cable['a_device'], cable['b_device']]))
found.append({
'name': cable['label'], 'kind': 'cable', 'status': 'unknown', 'ip': '', 'mac': '',
'model': f'{cable["a_device"]} ↔ {cable["b_device"] or "unterminated"}',
'url': f'/cutsheet#cable-{cable["id"]}', 'interface_count': 0,
'search': ' '.join(filter(None, [cable['label'], ends, cable.get('cable_type'),
cable.get('color'), 'cable cutsheet'])).lower(),
})
return jsonify({'devices': found})
@app.route('/api/device/<path:name>')
@@ -385,6 +522,12 @@ def api_device(name: str):
events = db.get_events_for_target(name)
_annotate_suppressions(events, db.get_active_suppressions())
detail['events'] = events
try:
detail['cutsheet'] = _cutsheet_for_device(name)
except Exception as e:
logger.error(f'Cutsheet unavailable for {name}: {e}')
detail['cutsheet'] = []
detail['inventory'] = _inventory_for(name, detail.get('model') or '')
return jsonify(detail)
@@ -459,7 +602,7 @@ def api_create_suppression():
)
logger.info(
f'Suppression #{sup_id} created by {user["username"]}: '
f'{target_type}/{target_name}/{target_detail} – {reason}'
f'{target_type}/{target_name}/{target_detail}: {reason}'
)
return jsonify({'success': True, 'id': sup_id})
@@ -626,7 +769,7 @@ def api_diagnose_poll(job_id: str):
@require_auth
def api_avatar():
"""Serve the current user's LDAP avatar photo (JPEG), cached to disk."""
username = request.headers.get('Remote-User', '').strip()
username = _get_user()['username'].strip()
if not username:
return '', 404
@@ -671,7 +814,7 @@ def api_avatar():
# Query lldap
bind_pw = ldap_cfg.get('bind_pw', '')
if not bind_pw:
logger.error('LDAP bind_pw not configured — avatar lookup disabled')
logger.error('LDAP bind_pw not configured: avatar lookup disabled')
return '', 404
avatar_data = None
@@ -689,7 +832,7 @@ def api_avatar():
if conn.entries and conn.entries[0]['avatar'].value:
avatar_data = conn.entries[0]['avatar'].value
except ImportError:
logger.error('ldap3 not installed — run: pip install ldap3')
logger.error('ldap3 not installed; run pip install ldap3')
return '', 404
except Exception as e:
logger.error(f'LDAP avatar lookup failed for {username}: {e}')
@@ -727,6 +870,514 @@ def api_avatar():
return resp
# ---------------------------------------------------------------------------
# Cutsheets
# ---------------------------------------------------------------------------
_cutsheet_schema_ready = False
_cutsheet_schema_lock = threading.Lock()
def _ensure_cutsheet_schema() -> None:
"""Create the cutsheet tables on first use, so deploys need no migration step."""
global _cutsheet_schema_ready
if _cutsheet_schema_ready:
return
with _cutsheet_schema_lock:
if not _cutsheet_schema_ready:
db.ensure_cutsheet_schema()
_cutsheet_schema_ready = True
def _node_json(node) -> dict:
if node is None:
return {'device': '', 'port': '', 'side': '', 'text': 'unterminated'}
return {'device': node[0], 'port': node[1], 'side': node[2], 'text': cutsheet.describe_node(node)}
def _cutsheet_catalog(link_stats: dict, items: list) -> list:
"""Devices and their ports, for the cable form's suggestions."""
catalog = []
for name, sw in sorted((link_stats.get('unifi_switches') or {}).items()):
ports = sorted((p for p in (sw.get('ports') or {}).items() if p[1].get('port_idx') is not None),
key=lambda kv: kv[1]['port_idx'])
catalog.append({'name': name, 'kind': 'switch', 'ports': [
{'value': str(p['port_idx']), 'text': f'{p["port_idx"]} · {pname}'} for pname, p in ports]})
for name, ifaces in sorted((link_stats.get('hosts') or {}).items()):
catalog.append({'name': name, 'kind': 'host',
'ports': [{'value': i, 'text': i} for i in sorted(ifaces)]})
known = {c['name'] for c in catalog}
for item in items:
if item['name'] in known:
continue
ports = [{'value': str(n), 'text': str(n)} for n in range(1, (item.get('port_count') or 0) + 1)]
catalog.append({'name': item['name'], 'kind': item['kind'], 'ports': ports})
return catalog
def _cutsheet_view() -> dict:
"""Every cutsheet record with its traced path and plan-vs-actual verdict."""
_ensure_cutsheet_schema()
data = db.cutsheet_load()
link_stats = _state_json('link_stats')
switches = link_stats.get('unifi_switches') or {}
items = {i['name']: i for i in data['items']}
results = cutsheet.evaluate(data['cables'], items, switches)
for cable in data['cables']:
r = results[cable['id']]
cable['verdict'] = r['verdict']
cable['detail'] = r['detail']
cable['problem'] = r['verdict'] in cutsheet.PROBLEM_VERDICTS
cable['path'] = [
{'cable_id': h} if isinstance(h, int) else _node_json(h) for h in r['path']['hops']
]
cable['a_text'] = cutsheet.describe_node(cutsheet._node(cable, 'a'))
cable['b_text'] = cutsheet.describe_node(cutsheet._node(cable, 'b'))
data['suggestions'] = cutsheet.undocumented(data['cables'], switches, items)
data['labels'] = cutsheet.labels_to_make(data['cables'], items, data['port_labels'])
data['next_label'] = cutsheet.next_label(data['cables'])
data['catalog'] = _cutsheet_catalog(link_stats, data['items'])
data['racks'] = [r['name'] for r in _racks(data['items'])]
snapshot = _state_json('network_snapshot')
data['devices'] = sorted(set(switches) | set(snapshot.get('hosts') or {})
| {u['name'] for u in snapshot.get('unifi') or [] if u.get('name')}, key=str.lower)
data['verdicts'] = cutsheet.VERDICTS
data['chassis'] = cutsheet.CHASSIS
data['options'] = {'kinds': cutsheet.ITEM_KINDS, 'passive_kinds': cutsheet.PASSIVE_KINDS,
'statuses': cutsheet.STATUSES, 'cable_types': cutsheet.CABLE_TYPES}
data['updated'] = link_stats.get('updated')
return data
def _cutsheet_for_device(name: str) -> list:
"""The cables that end on one device, for its port panel."""
view = _cutsheet_view()
# Cables may name the device or a cutsheet item linked to it
names = {name} | {i['name'] for i in view['items'] if i.get('device') == name}
out = []
for cable in view['cables']:
for end in ('a', 'b'):
if cable[f'{end}_device'] in names and cable['status'] != 'retired':
out.append({
'port': cable[f'{end}_port'], 'side': cable[f'{end}_side'], 'id': cable['id'],
'label': cable['label'], 'status': cable['status'], 'verdict': cable['verdict'],
'detail': cable['detail'], 'problem': cable['problem'], 'path': cable['path'],
})
return out
def _json_body() -> dict:
"""The request's JSON object. Requiring a JSON content type also keeps another
site's plain form post from reaching these write endpoints (no CORS preflight)."""
if not request.is_json:
raise cutsheet.ValidationError('Send the request as JSON')
data = request.get_json(silent=True)
if not isinstance(data, dict):
raise cutsheet.ValidationError('Request body must be a JSON object')
return data
def _cutsheet_write(fn):
"""Turn validation and conflict errors from a write into 400 and 409 responses."""
@wraps(fn)
def wrapper(*args, **kwargs):
try:
_ensure_cutsheet_schema()
return fn(*args, **kwargs)
except cutsheet.ValidationError as e:
return jsonify({'error': str(e)}), 400
except db.CutsheetConflict as e:
return jsonify({'error': str(e)}), 409
return wrapper
def _cutsheet_items() -> dict:
return {i['name']: i for i in db.cutsheet_load()['items']}
@app.route('/cutsheet')
@require_auth
def cutsheet_page():
user = _get_user()
return render_template('cutsheet.html', user=user, can_edit='admin' in user['groups'])
@app.route('/api/cutsheet')
@require_auth
def api_cutsheet():
view = _cutsheet_view()
view['history'] = db.cutsheet_history(limit=100)
return jsonify(view)
# ---------------------------------------------------------------------------
# Inventory (HomeBox) links
# ---------------------------------------------------------------------------
_INVENTORY_DEFAULT = 'https://inventory.lotusguild.org'
def _inventory_base() -> str:
return ((_config().get('inventory') or {}).get('base_url') or _INVENTORY_DEFAULT).rstrip('/')
def _inventory_for(name: str, model: str) -> dict:
"""The device's inventory record link, or a search to find it."""
base = _inventory_base()
template = (_config().get('inventory') or {}).get('search_url') or '{base}/items?q={q}'
try:
_ensure_cutsheet_schema()
url = db.get_device_link(name)
except Exception as e:
logger.error(f'Inventory link unavailable for {name}: {e}')
url = ''
return {'url': url, 'search_url': template.format(base=base, q=quote(model or name, safe=''))}
def _validate_inventory_url(value) -> str:
"""Only links into the configured inventory site: this URL is shown as a link to every viewer."""
url = str(value or '').strip()
if not url:
return ''
if len(url) > 512:
raise cutsheet.ValidationError('Inventory link is too long')
base = urlparse(_inventory_base())
got = urlparse(url)
if got.scheme != 'https' or got.netloc.lower() != base.netloc.lower() or got.username or got.password:
raise cutsheet.ValidationError(f'Inventory link must start with {base.scheme}://{base.netloc}/')
return url
@app.route('/api/device/<path:name>/inventory', methods=['PUT'])
@require_auth
@require_admin
@_cutsheet_write
def api_device_inventory(name: str):
"""Set or clear (empty url) the device's inventory link."""
if len(name) > 255:
raise cutsheet.ValidationError('Device name is too long')
url = _validate_inventory_url(_json_body().get('url'))
db.set_device_link(name, url, _get_user()['username'])
logger.info(f'{_get_user()["username"]} set inventory link for {name}: {url or "(removed)"}')
return jsonify({'success': True, 'url': url})
# ---------------------------------------------------------------------------
# Rack elevation
# ---------------------------------------------------------------------------
@app.route('/rack')
@require_auth
def rack_page():
user = _get_user()
return render_template('rack.html', user=user, can_edit='admin' in user['groups'])
def _racks(items: list) -> list:
"""Every rack, in order: those saved on the rack page, then any other name an item uses.
With none saved, racks come from config: "racks": [{"name": "Main", "units": 42}, ...], or
one rack named rack.name (default "Rack 1") with rack.units (default 42). Those have no id
until saved. An item with no rack belongs to the first.
"""
def units(value, default=42):
try:
return max(1, min(int(value), 60))
except (TypeError, ValueError):
return default
cfg = _config()
single = cfg.get('rack') or {}
default_units = units(single.get('units', 42))
racks = [{'id': r['id'], 'name': r['name'], 'units': r['units'], 'notes': r.get('notes') or ''}
for r in db.cutsheet_racks()]
if not racks:
racks = [{'id': None, 'name': str(r.get('name') or '').strip(), 'notes': '',
'units': units(r.get('units', default_units), default_units)}
for r in cfg.get('racks') or [] if isinstance(r, dict) and str(r.get('name') or '').strip()]
if not racks:
racks = [{'id': None, 'name': str(single.get('name') or 'Rack 1'), 'units': default_units, 'notes': ''}]
named = {r['name'] for r in racks}
for item in items:
if item.get('rack') and item['rack'] not in named:
named.add(item['rack'])
racks.append({'id': None, 'name': item['rack'], 'units': default_units, 'notes': ''})
return racks
def _device_status(name: str, snapshot: dict) -> str:
host = (snapshot.get('hosts') or {}).get(name)
if host:
return host.get('status') or 'unknown'
for d in snapshot.get('unifi') or []:
if d.get('name') == name:
return 'up' if d.get('connected') else 'down'
return 'unknown'
@app.route('/api/rack')
@require_auth
def api_rack():
"""One rack face: placed cutsheet items, live switch ports, and each port's cutsheet state.
Query: rack (name; default the first rack), face (front|rear).
"""
face = request.args.get('face', 'front')
if face not in ('front', 'rear'):
return jsonify({'error': 'face must be front or rear'}), 400
view = _cutsheet_view()
link_stats = _state_json('link_stats')
switches = link_stats.get('unifi_switches') or {}
unifi_info = link_stats.get('unifi_devices') or {}
snapshot = _state_json('network_snapshot')
online = {d['name']: d.get('connected', True) for d in snapshot.get('unifi') or []}
known = set(switches) | set(online) | set(snapshot.get('hosts') or {})
racks = _racks(view['items'])
default = racks[0]['name']
current = next((r for r in racks if r['name'] == request.args.get('rack', default)), None)
if current is None:
return jsonify({'error': 'No such rack'}), 404
def rack_of(item):
return item.get('rack') or default
for r in racks:
racked = [i for i in view['items'] if not i.get('shelf') and i.get('rack_u') and rack_of(i) == r['name']]
r['count'] = len(racked)
r['rear'] = sum(1 for i in racked if i.get('mount') in ('rear', 'full'))
for cable in view['cables']:
cable['run'] = [h['cable_id'] for h in cable['path'] if 'cable_id' in h]
marks = cutsheet.port_marks(view['cables'])
labels: dict = {}
for pl in view['port_labels']:
labels.setdefault(pl['item_name'], {})[str(pl['port'])] = pl['label']
def dev(item):
# An item can be named after the product ("UDM-Pro") and linked to the live device
return item.get('device') or item['name']
def url(item):
return f'/device/{quote(dev(item), safe="")}' if dev(item) in known else f'/cutsheet#item-{item["id"]}'
on_shelf: dict = {}
for item in view['items']:
if item.get('shelf'):
on_shelf.setdefault(item['shelf'], []).append(item)
here = [i for i in view['items'] if not i.get('shelf') and rack_of(i) == current['name']]
layout = cutsheet.rack_layout(here, current['units'], face)
out = []
for item in layout['placed']:
name, device = item['name'], dev(item)
entry = {k: item.get(k) for k in ('id', 'name', 'kind', 'port_count', 'rack_u', 'rack_height',
'rack_top', 'location', 'notes')}
entry['device'] = device
entry['linked'] = device in known
entry['mount'] = item.get('mount') or 'front'
entry['chassis'] = item.get('chassis') or ''
entry['through'] = item.get('through', False)
entry['url'] = url(item)
entry['status'] = _device_status(device, snapshot) if device in known else ''
# Cables may name either the item or the device it is linked to
entry['ports'] = {port: m for (d, port), m in marks.items() if d in (name, device)}
entry['labels'] = labels.get(name, {})
model = next((u.get('model') for u in snapshot.get('unifi') or [] if u.get('name') == device), '')
if device in switches or model:
sw = switches.get(device) or {}
entry['switch'] = {'model': sw.get('model') or model or '', 'ports': sw.get('ports') or {},
'outlets': (unifi_info.get(device) or {}).get('outlets') or [],
'online': online.get(device, True)}
if item['kind'] == 'shelf':
entry['contents'] = [
{'id': c['id'], 'name': c['name'], 'kind': c['kind'], 'url': url(c),
'status': _device_status(dev(c), snapshot) if dev(c) in known else '',
'model': next((u.get('model') for u in snapshot.get('unifi') or [] if u.get('name') == dev(c)), '')
or '', 'notes': c.get('notes') or ''}
for c in sorted(on_shelf.get(name, []), key=lambda c: c['name'].lower())
]
out.append(entry)
return jsonify({
'racks': racks, 'rack': current['name'], 'rack_id': current['id'], 'units': current['units'],
'notes': current['notes'], 'face': face, 'items': out,
'overlaps': layout['overlaps'], 'outside': layout['outside'],
'unplaced': sorted(i['name'] for i in here if not i.get('rack_u')),
'updated': link_stats.get('updated'),
})
@app.route('/api/cutsheet/racks', methods=['POST'])
@require_auth
@require_admin
@_cutsheet_write
def api_cutsheet_create_rack():
"""Add a rack. `previous` is the name of the default rack this replaces, when the first is saved."""
body = _json_body()
rack = cutsheet.validate_rack(body)
previous = str(body.get('previous') or '')[:100] if not db.cutsheet_racks() else ''
rack_id = db.cutsheet_save_rack(None, rack, _get_user()['username'], previous=previous)
return jsonify({'success': True, 'id': rack_id})
@app.route('/api/cutsheet/racks/<int:rack_id>', methods=['PUT'])
@require_auth
@require_admin
@_cutsheet_write
def api_cutsheet_update_rack(rack_id: int):
rack = cutsheet.validate_rack(_json_body())
db.cutsheet_save_rack(rack_id, rack, _get_user()['username'])
return jsonify({'success': True})
@app.route('/api/cutsheet/racks/<int:rack_id>', methods=['DELETE'])
@require_auth
@require_admin
@_cutsheet_write
def api_cutsheet_delete_rack(rack_id: int):
if not db.cutsheet_delete_rack(rack_id, _get_user()['username']):
return jsonify({'error': 'No such rack'}), 404
return jsonify({'success': True})
@app.route('/api/cutsheet/cables', methods=['POST'])
@require_auth
@require_admin
@_cutsheet_write
def api_cutsheet_create_cable():
cable = cutsheet.validate_cable(_json_body(), _cutsheet_items())
cable_id = db.cutsheet_create_cable(cable, _get_user()['username'])
return jsonify({'success': True, 'id': cable_id})
@app.route('/api/cutsheet/cables/<int:cable_id>', methods=['PUT'])
@require_auth
@require_admin
@_cutsheet_write
def api_cutsheet_update_cable(cable_id: int):
cable = cutsheet.validate_cable(_json_body(), _cutsheet_items())
if not db.cutsheet_update_cable(cable_id, cable, _get_user()['username']):
return jsonify({'error': 'No such cable'}), 404
return jsonify({'success': True})
@app.route('/api/cutsheet/cables/<int:cable_id>', methods=['DELETE'])
@require_auth
@require_admin
@_cutsheet_write
def api_cutsheet_delete_cable(cable_id: int):
if not db.cutsheet_delete_cable(cable_id, _get_user()['username']):
return jsonify({'error': 'No such cable'}), 404
return jsonify({'success': True})
@app.route('/api/cutsheet/items', methods=['POST'])
@require_auth
@require_admin
@_cutsheet_write
def api_cutsheet_create_item():
item = cutsheet.validate_item(_json_body(), _cutsheet_items())
item_id = db.cutsheet_create_item(item, _get_user()['username'])
return jsonify({'success': True, 'id': item_id})
@app.route('/api/cutsheet/items/<int:item_id>', methods=['PUT'])
@require_auth
@require_admin
@_cutsheet_write
def api_cutsheet_update_item(item_id: int):
item = cutsheet.validate_item(_json_body(), _cutsheet_items())
if not db.cutsheet_update_item(item_id, item, _get_user()['username']):
return jsonify({'error': 'No such item'}), 404
return jsonify({'success': True})
@app.route('/api/cutsheet/items/<int:item_id>', methods=['DELETE'])
@require_auth
@require_admin
@_cutsheet_write
def api_cutsheet_delete_item(item_id: int):
if not db.cutsheet_delete_item(item_id, _get_user()['username']):
return jsonify({'error': 'No such item'}), 404
return jsonify({'success': True})
@app.route('/api/cutsheet/items/<int:item_id>/ports/<port>', methods=['PUT'])
@require_auth
@require_admin
@_cutsheet_write
def api_cutsheet_port_label(item_id: int, port: str):
data = _json_body()
label = str(data.get('label') or '').strip()
if len(label) > 64:
raise cutsheet.ValidationError('Port label must be 64 characters or fewer')
if len(port) > cutsheet.PORT_MAX:
raise cutsheet.ValidationError('Port is too long')
if not db.cutsheet_set_port_label(item_id, port, label, bool(data.get('applied')), _get_user()['username']):
return jsonify({'error': 'No such item'}), 404
return jsonify({'success': True})
_live_ports_cache: dict = {'at': 0.0, 'data': None, 'client': None}
_live_ports_lock = threading.Lock()
_LIVE_PORTS_TTL = 2.0
@app.route('/api/cutsheet/live-ports')
@require_auth
@require_admin
def api_cutsheet_live_ports():
"""Current up/down state of every switch port, read from UniFi now.
Trace mode polls this while someone unplugs a cord, to see which port dropped.
The monitor's cached state is minutes old, so it can't be used for this.
"""
with _live_ports_lock:
now = time.time()
if _live_ports_cache['data'] is None or now - _live_ports_cache['at'] > _LIVE_PORTS_TTL:
if _live_ports_cache['client'] is None:
_live_ports_cache['client'] = UnifiClient(_config()['unifi'])
raw = _live_ports_cache['client'].get_switch_ports()
if raw is None:
return jsonify({'error': 'The UniFi controller did not answer'}), 502
_live_ports_cache['data'] = {
sw: {str(p['port_idx']): {'up': bool(p.get('up')), 'name': name}
for name, p in (d.get('ports') or {}).items() if p.get('port_idx') is not None}
for sw, d in raw.items()
}
_live_ports_cache['at'] = now
return jsonify({'switches': _live_ports_cache['data'], 'at': _live_ports_cache['at']})
@app.route('/api/cutsheet/cables.csv')
@require_auth
def api_cutsheet_export():
_ensure_cutsheet_schema()
resp = make_response(cutsheet.cables_to_csv(db.cutsheet_load()['cables']))
resp.headers['Content-Type'] = 'text/csv; charset=utf-8'
resp.headers['Content-Disposition'] = 'attachment; filename="gandalf-cutsheet.csv"'
return resp
@app.route('/api/cutsheet/import', methods=['POST'])
@require_auth
@require_admin
@_cutsheet_write
def api_cutsheet_import():
data = _json_body()
text = data.get('csv')
if not isinstance(text, str) or not text.strip():
raise cutsheet.ValidationError('Paste or choose a CSV file')
if len(text) > 1_000_000:
raise cutsheet.ValidationError('CSV is larger than 1 MB')
cables, errors = cutsheet.parse_csv(text, _cutsheet_items())
if errors:
return jsonify({'error': 'Nothing was imported', 'errors': errors[:50]}), 400
if data.get('dry_run'):
return jsonify({'success': True, 'dry_run': True, 'rows': len(cables)})
result = db.cutsheet_import_cables(cables, _get_user()['username'])
return jsonify(dict(result, success=True))
@app.route('/health')
def health():
"""Health check endpoint (no auth). Checks DB and monitor freshness."""
@@ -742,19 +1393,19 @@ def health():
checks['db'] = 'error'
overall = 'degraded'
# Monitor freshness: fail if last_check is older than 20 minutes
# Monitor freshness: a hung or crashed monitor stops updating last_check
try:
last_check = db.get_state('last_check', '')
if last_check:
ts = datetime.strptime(last_check, '%Y-%m-%d %H:%M:%S UTC').replace(tzinfo=timezone.utc)
age_s = (datetime.now(timezone.utc) - ts).total_seconds()
if age_s > 1200:
checks['monitor'] = 'stale'
overall = 'degraded'
else:
checks['monitor'] = 'ok'
else:
age_s = _monitor_age(last_check)
if not last_check:
checks['monitor'] = 'no data yet'
elif age_s is None or age_s > _monitor_stale_after():
checks['monitor'] = 'stale'
checks['monitor_age_s'] = int(age_s) if age_s is not None else None
overall = 'degraded'
else:
checks['monitor'] = 'ok'
checks['monitor_age_s'] = int(age_s)
except Exception as e:
logger.error(f'Health check monitor error: {e}')
checks['monitor'] = 'error'
@@ -765,4 +1416,4 @@ def health():
if __name__ == '__main__':
app.run(debug=True, host='0.0.0.0', port=5000) # nosec B201 B104 — dev runner only; production uses gunicorn
app.run(debug=True, host='0.0.0.0', port=5000) # nosec B201 B104: dev runner only; production uses gunicorn
+679
View File
@@ -0,0 +1,679 @@
"""Cutsheets: where every cable is meant to go, compared with what Gandalf sees.
Pure functions with no I/O, like devices.py. app.py loads rows from the
database and the monitor's cached link stats and passes them in.
Model
-----
* An **item** is something Gandalf can't discover: a patch panel, a wall jack,
a shelf, or a rack position for a device. Items of a passive kind (panels and
jacks) pass a signal straight through, from a port's front to the same port's
rear.
* A **cable** joins two endpoints. An endpoint is a device or item name, a port
(a switch's port number, a host's interface name, or a panel port), and for
passive items a side. The far end may be left blank for a cable that ends
nowhere yet, such as an unterminated fibre.
* A **path** is the chain of cables joined through passive items, e.g. switch
port 13 → panel port 5 (front) … panel port 5 (rear) → bedroom jack.
"""
import csv
import io
import re
from typing import Dict, List, Optional, Tuple
ITEM_KINDS = ('patch_panel', 'wall_jack', 'device', 'shelf', 'other')
# Which side of a 4-post rack an item is mounted from. A front and a rear item can share
# a unit; a full-depth one (a server) takes the unit on both sides.
MOUNTS = ('front', 'rear', 'full')
RACK_UNITS_MAX = 60
# Drawn fronts for gear without a live faceplate (keys of RACK_FRONTS in static/fronts.js)
CHASSIS = {
'unvr-pro': 'UniFi NVR Pro (UNVR Pro)',
'uacc-patch-24': 'UniFi Patch Panel Blank 24 (UACC-Rack-Panel-Patch-Blank-24)',
'sliger-cx4712': 'Sliger CX4712 4U (10-bay)',
'rosewill-rsv-l4500u': 'Rosewill RSV-L4500U 4U (15-bay)',
'server-1u': 'Generic 1U server',
'server-2u': 'Generic 2U server',
'server-4u': 'Generic 4U server',
}
PASSIVE_KINDS = ('patch_panel', 'wall_jack')
SIDES = ('front', 'rear')
STATUSES = ('planned', 'installed', 'dark', 'retired')
CABLE_TYPES = ('Cat5e', 'Cat6', 'Cat6a', 'DAC', 'AOC', 'OM3', 'OM4', 'OS2', 'Power', 'Other')
LABEL_RE = re.compile(r'^[A-Za-z0-9][A-Za-z0-9._-]{0,31}$')
NAME_MAX = 100
PORT_MAX = 64
TEXT_MAX = 255
NOTES_MAX = 2000
RACK_NAME_MAX = 100
# Comparison outcomes, and whether each counts as a problem
VERDICTS = {
'match': 'Matches what Gandalf sees',
'wrong_neighbor': 'A different device is connected',
'no_link': 'Planned device is not linked',
'missing_port': 'That port is not reported by the device',
'unverified': "Gandalf can't confirm the far end",
'idle': 'Ends at a jack or panel with nothing linked',
'not_checked': 'No switch port to check against',
'planned': 'Planned, not installed yet',
'dark': 'Unused (dark)',
'retired': 'Retired',
'conflict': 'Another cable uses the same port',
}
PROBLEM_VERDICTS = ('wrong_neighbor', 'no_link', 'missing_port', 'conflict')
class ValidationError(ValueError):
"""A request the cutsheet can't accept, with a message for the user."""
# ── Validation ──────────────────────────────────────────────────────────────
def _text(data: dict, key: str, limit: int = TEXT_MAX, required: bool = False, label: str = '') -> str:
value = data.get(key)
value = '' if value is None else str(value).strip()
if required and not value:
raise ValidationError(f'{label or key} is required')
if len(value) > limit:
raise ValidationError(f'{label or key} must be {limit} characters or fewer')
return value
def _int(data: dict, key: str, low: int, high: int, label: str) -> Optional[int]:
value = data.get(key)
if value in (None, ''):
return None
try:
number = int(value)
except (TypeError, ValueError):
raise ValidationError(f'{label} must be a whole number')
if not low <= number <= high:
raise ValidationError(f'{label} must be between {low} and {high}')
return number
def validate_item(data: dict, items: Optional[Dict[str, dict]] = None) -> dict:
"""An item from a form. `items` (by name) is needed to check a shelf placement."""
kind = _text(data, 'kind', 20) or 'other'
if kind not in ITEM_KINDS:
raise ValidationError(f'kind must be one of {", ".join(ITEM_KINDS)}')
item = {
'name': _text(data, 'name', NAME_MAX, required=True, label='Name'),
'kind': kind,
'port_count': _int(data, 'port_count', 1, 512, 'Port count'),
'location': _text(data, 'location'),
'rack_u': _int(data, 'rack_u', 1, 60, 'Rack unit'),
'rack_height': _int(data, 'rack_height', 1, 20, 'Height'),
'rack': _text(data, 'rack', RACK_NAME_MAX),
'device': _text(data, 'device'),
'mount': _text(data, 'mount', 10) or 'front',
'chassis': _text(data, 'chassis', 40),
'shelf': _text(data, 'shelf', NAME_MAX),
'notes': _text(data, 'notes', NOTES_MAX),
}
if item['chassis'] and item['chassis'] not in CHASSIS:
raise ValidationError(f'Unknown front drawing {item["chassis"]}')
if item['mount'] not in MOUNTS:
raise ValidationError(f'mount must be one of {", ".join(MOUNTS)}')
if item['shelf']:
shelf = (items or {}).get(item['shelf'])
if not shelf or shelf['kind'] != 'shelf':
raise ValidationError(f'{item["shelf"]} is not a shelf on the cutsheet')
if kind == 'shelf' or shelf['name'] == item['name']:
raise ValidationError('A shelf cannot sit on a shelf')
if item['rack_u'] or item['rack_height']:
raise ValidationError('An item on a shelf takes its rack position from the shelf; clear the rack unit')
item['rack'] = '' # the shelf's rack and side
item['mount'] = 'front'
if item['rack_height'] and not item['rack_u']:
raise ValidationError('Set a rack unit to go with the height')
if item['rack_u'] and not item['rack_height']:
item['rack_height'] = 1
if kind == 'patch_panel' and not item['port_count']:
raise ValidationError('A patch panel needs a port count')
return item
def _endpoint(data: dict, prefix: str, items: Dict[str, dict], required: bool) -> Tuple[str, str, str]:
device = _text(data, f'{prefix}_device', NAME_MAX, required=required,
label='From device' if prefix == 'a' else 'To device')
port = _text(data, f'{prefix}_port', PORT_MAX)
side = _text(data, f'{prefix}_side', 10)
if not device:
if port or side:
raise ValidationError('Choose a device before a port')
return '', '', ''
item = items.get(device)
passive = bool(item and item['kind'] in PASSIVE_KINDS)
if passive:
if side not in SIDES:
raise ValidationError(f'Choose the front or rear of {device}')
if not port:
raise ValidationError(f'Choose a port on {device}')
count = item.get('port_count')
if count and (not port.isdigit() or not 1 <= int(port) <= count):
raise ValidationError(f'{device} has ports 1 to {count}')
else:
side = ''
return device, port, side
def validate_cable(data: dict, items: Dict[str, dict]) -> dict:
label = _text(data, 'label', 32)
if label and not LABEL_RE.match(label):
raise ValidationError('Label may use letters, digits, dot, dash and underscore (up to 32)')
status = _text(data, 'status', 20) or 'installed'
if status not in STATUSES:
raise ValidationError(f'status must be one of {", ".join(STATUSES)}')
cable_type = _text(data, 'cable_type', 32)
if cable_type and cable_type not in CABLE_TYPES:
raise ValidationError(f'Type must be one of {", ".join(CABLE_TYPES)}')
length = data.get('length_m')
if length in (None, ''):
length = None
else:
try:
length = round(float(length), 2)
except (TypeError, ValueError):
raise ValidationError('Length must be a number of metres')
if not 0 < length <= 999:
raise ValidationError('Length must be between 0 and 999 metres')
a = _endpoint(data, 'a', items, required=True)
b = _endpoint(data, 'b', items, required=False)
if a == b:
raise ValidationError('Both ends are the same port')
return {
'label': label or None,
'a_device': a[0], 'a_port': a[1], 'a_side': a[2],
'b_device': b[0], 'b_port': b[1], 'b_side': b[2],
'cable_type': cable_type, 'length_m': length,
'color': _text(data, 'color', 32), 'status': status,
'notes': _text(data, 'notes', NOTES_MAX),
'label_applied': bool(data.get('label_applied')),
}
def next_label(cables: List[dict], prefix: str = 'C') -> str:
"""The next free cable ID: C01, C02, ... (wider once past 99)."""
used = set()
for c in cables:
m = re.match(rf'^{re.escape(prefix)}(\d+)$', c.get('label') or '', re.IGNORECASE)
if m:
used.add(int(m.group(1)))
n = 1
while n in used:
n += 1
return f'{prefix}{n:02d}'
# ── Paths ───────────────────────────────────────────────────────────────────
def _node(cable: dict, end: str) -> Optional[tuple]:
device = cable.get(f'{end}_device') or ''
if not device:
return None
return (device, cable.get(f'{end}_port') or '', cable.get(f'{end}_side') or '')
def _other_side(node: tuple, items: Dict[str, dict]) -> Optional[tuple]:
"""Through a passive item, the same port's other side; otherwise the path ends."""
item = items.get(node[0])
if not item or item['kind'] not in PASSIVE_KINDS or node[2] not in SIDES:
return None
return (node[0], node[1], 'rear' if node[2] == 'front' else 'front')
def _live(cable: dict) -> bool:
return cable.get('status') != 'retired'
def node_index(cables: List[dict]) -> Dict[tuple, List[dict]]:
"""Map each endpoint to the live cables plugged into it."""
index: Dict[tuple, List[dict]] = {}
for c in cables:
if not _live(c):
continue
for end in ('a', 'b'):
node = _node(c, end)
if node:
index.setdefault(node, []).append(c)
return index
def trace(cable: dict, cables: List[dict], items: Dict[str, dict],
index: Optional[Dict[tuple, List[dict]]] = None) -> dict:
"""Follow a cable through passive items in both directions.
Returns {'hops': [node, cable_id, node, ...], 'cable_ids': [...]} with the
hops ordered from one end of the run to the other. A node is
(device, port, side), or None for an unterminated end.
"""
index = index if index is not None else node_index(cables)
def walk(node: Optional[tuple], came_from: dict, seen: set) -> list:
hops = []
while node is not None:
through = _other_side(node, items)
if through is None:
break
nxt = next((c for c in index.get(through, []) if c['id'] != came_from['id'] and c['id'] not in seen),
None)
hops.append(through)
if nxt is None:
break
seen.add(nxt['id'])
hops.append(nxt['id'])
far = 'b' if _node(nxt, 'a') == through else 'a'
node = _node(nxt, far)
hops.append(node)
came_from = nxt
return hops
seen = {cable['id']}
toward_a = walk(_node(cable, 'a'), cable, seen)
toward_b = walk(_node(cable, 'b'), cable, seen)
hops = list(reversed(toward_a)) + [_node(cable, 'a'), cable['id'], _node(cable, 'b')] + toward_b
return {'hops': hops, 'cable_ids': [h for h in hops if isinstance(h, int)]}
# ── Plan vs. actual ─────────────────────────────────────────────────────────
def _switch_port(node: Optional[tuple], switches: dict) -> Optional[dict]:
"""The discovered port behind an endpoint, if it is a switch or router port."""
if not node or node[0] not in switches or not node[1].isdigit():
return None
for port in (switches[node[0]].get('ports') or {}).values():
if port.get('port_idx') == int(node[1]):
return port
return {} # the device is known but doesn't report this port
def _same(a: str, b: str) -> bool:
return bool(a) and bool(b) and a.strip().lower() == b.strip().lower()
def device_of(name: str, items: Dict[str, dict]) -> str:
"""The live device an item name stands for: its linked device, or the name itself."""
return (items.get(name) or {}).get('device') or name
def with_aliases(switches: dict, items: Dict[str, dict]) -> dict:
"""Switches also reachable by the name of an item linked to them (item "UDM-Pro" -> "Dream Machine Pro")."""
out = dict(switches or {})
for name, item in (items or {}).items():
device = item.get('device')
if device and device in out and name not in out:
out[name] = out[device]
return out
def _check_end(node: tuple, other: Optional[tuple], switches: dict, items: Dict[str, dict]) -> Optional[dict]:
port = _switch_port(node, switches)
if port is None:
return None
if port == {}:
return {'verdict': 'missing_port', 'detail': f'{node[0]} reports no port {node[1]}'}
other_passive = other is None or (items.get(other[0], {}).get('kind') in PASSIVE_KINDS)
expected = None if other_passive else device_of(other[0], items)
lldp = port.get('lldp') or {}
seen = lldp.get('system_name') or ''
sfp_peer = (port.get('sfp') or {}).get('cable_peer')
if sfp_peer and other is not None and not other_passive:
if _same(sfp_peer.get('switch', ''), device_of(other[0], items)) and str(sfp_peer.get('port_idx')) == other[1]:
return {'verdict': 'match', 'detail': 'Both ends report the same DAC serial'}
if not port.get('up'):
if expected:
return {'verdict': 'no_link', 'detail': f'{node[0]} port {node[1]} is down'}
return {'verdict': 'idle', 'detail': f'{node[0]} port {node[1]} is down'}
if expected:
if not seen:
return {'verdict': 'unverified', 'detail': f'Link up on port {node[1]}, but no neighbor is identified'}
if _same(seen, expected):
return {'verdict': 'match', 'detail': f'{node[0]} port {node[1]} sees {seen}'}
return {'verdict': 'wrong_neighbor', 'detail': f'{node[0]} port {node[1]} sees {seen}, not {expected}'}
detail = f'Link up on port {node[1]}' + (f', sees {seen}' if seen else '')
return {'verdict': 'unverified', 'detail': detail}
_VERDICT_RANK = ['wrong_neighbor', 'no_link', 'missing_port', 'unverified', 'idle', 'match']
def compare_path(path: dict, cables_by_id: Dict[int, dict], switches: dict, items: Dict[str, dict]) -> dict:
"""Check a traced run against discovery. Returns {'verdict', 'detail'}."""
run = [cables_by_id[i] for i in path['cable_ids']]
statuses = {c['status'] for c in run}
for status in ('retired', 'dark', 'planned'):
if status in statuses:
return {'verdict': status, 'detail': VERDICTS[status]}
ends = (path['hops'][0], path['hops'][-1])
checks = [c for c in (_check_end(ends[0], ends[1], switches, items),
_check_end(ends[1], ends[0], switches, items)) if c]
if not checks:
return {'verdict': 'not_checked', 'detail': VERDICTS['not_checked']}
# A switch-to-switch run is checked from both ends: report the worst
return min(checks, key=lambda c: _VERDICT_RANK.index(c['verdict']))
def evaluate(cables: List[dict], items: Dict[str, dict], switches: dict) -> Dict[int, dict]:
"""Trace and compare every cable. Returns {cable_id: {'path', 'verdict', 'detail'}}."""
switches = with_aliases(switches, items)
index = node_index(cables)
by_id = {c['id']: c for c in cables}
result: Dict[int, dict] = {}
for c in cables:
if not _live(c):
result[c['id']] = {'path': {'hops': [_node(c, 'a'), c['id'], _node(c, 'b')], 'cable_ids': [c['id']]},
'verdict': 'retired', 'detail': VERDICTS['retired']}
continue
conflict = next((n for n in (_node(c, 'a'), _node(c, 'b'))
if n and len([x for x in index.get(n, []) if x['status'] in ('installed', 'dark')]) > 1
and c['status'] in ('installed', 'dark')), None)
path = trace(c, cables, items, index)
if conflict:
others = [x.get('label') or f'#{x["id"]}' for x in index[conflict] if x['id'] != c['id']]
result[c['id']] = {'path': path, 'verdict': 'conflict',
'detail': f'{describe_node(conflict)} is also used by {", ".join(others)}'}
continue
result[c['id']] = dict(compare_path(path, by_id, switches, items), path=path)
return result
def describe_node(node: Optional[tuple]) -> str:
if node is None:
return 'unterminated'
device, port, side = node
text = device
if port:
text += f' port {port}' if port.isdigit() else f' {port}'
if side:
text += f' ({side})'
return text
# ── Undocumented links ──────────────────────────────────────────────────────
def undocumented(cables: List[dict], switches: dict, items: Optional[Dict[str, dict]] = None) -> List[dict]:
"""Linked switch ports that no live cable mentions, as suggestions to add."""
documented = set()
for c in cables:
if not _live(c):
continue
for end in ('a', 'b'):
node = _node(c, end)
if node:
documented.add((device_of(node[0], items or {}).lower(), node[1]))
suggestions = []
for sw_name, sw in sorted((switches or {}).items()):
for port_name, port in (sw.get('ports') or {}).items():
idx = port.get('port_idx')
if not port.get('up') or idx is None or (sw_name.lower(), str(idx)) in documented:
continue
lldp = port.get('lldp') or {}
sfp = port.get('sfp') or {}
peer = sfp.get('cable_peer')
suggestion = {
'switch': sw_name, 'port_idx': idx, 'port_name': port_name,
'neighbor': lldp.get('system_name') or '', 'neighbor_port': lldp.get('port_id') or '',
'speed_mbps': port.get('speed_mbps') or 0,
'cable_type': 'DAC' if sfp.get('kind') == 'dac' else '',
'via': 'lldp' if lldp.get('system_name') else '',
}
if lldp.get('source') == 'unifi-clients':
suggestion['via'] = 'client table'
if peer:
suggestion.update(neighbor=peer['switch'], neighbor_port=str(peer['port_idx']), via='DAC serial')
# Offer each DAC once, from the end that sorts first
if (peer['switch'].lower(), str(peer['port_idx'])) in documented:
continue
if (peer['switch'], peer['port_idx']) < (sw_name, idx):
continue
suggestions.append(suggestion)
return suggestions
# ── Labels to make ──────────────────────────────────────────────────────────
def labels_to_make(cables: List[dict], items: Dict[str, dict], port_labels: List[dict]) -> dict:
"""Cable IDs and panel-port labels that haven't been stuck on yet."""
cords = [
{'id': c['id'], 'text': c['label'], 'copies': 2 if c.get('b_device') else 1,
'where': f'{describe_node(_node(c, "a"))} ↔ {describe_node(_node(c, "b"))}'}
for c in sorted(cables, key=lambda c: _natural(c.get('label') or ''))
if c.get('label') and not c.get('label_applied') and c['status'] in ('installed', 'dark')
]
unlabeled = [c['id'] for c in cables if not c.get('label') and c['status'] in ('installed', 'dark')]
ports = [
{'item': p['item_name'], 'port': p['port'], 'text': p['label']}
for p in sorted(port_labels, key=lambda p: (p['item_name'].lower(), _natural(p['port'])))
if p.get('label') and not p.get('applied')
]
return {'cables': cords, 'ports': ports, 'unlabeled_cable_ids': unlabeled}
def _natural(text: str) -> list:
return [int(t) if t.isdigit() else t.lower() for t in re.split(r'(\d+)', text or '')]
# ── CSV ─────────────────────────────────────────────────────────────────────
CSV_FIELDS = ['label', 'a_device', 'a_port', 'a_side', 'b_device', 'b_port', 'b_side',
'cable_type', 'length_m', 'color', 'status', 'label_applied', 'notes']
def cables_to_csv(cables: List[dict]) -> str:
out = io.StringIO()
writer = csv.DictWriter(out, fieldnames=CSV_FIELDS, extrasaction='ignore', lineterminator='\n')
writer.writeheader()
for c in sorted(cables, key=lambda c: _natural(c.get('label') or '')):
row = {k: c.get(k) for k in CSV_FIELDS}
row['label_applied'] = 'yes' if c.get('label_applied') else ''
row['length_m'] = '' if c.get('length_m') is None else f'{float(c["length_m"]):g}'
# Keep spreadsheet apps from running a cell as a formula
writer.writerow({k: _csv_safe(v) for k, v in row.items()})
return out.getvalue()
def _csv_safe(value) -> str:
text = '' if value is None else str(value)
return "'" + text if text[:1] in ('=', '+', '-', '@', '\t', '\r') and not _is_number(text) else text
def _is_number(text: str) -> bool:
try:
float(text)
return True
except ValueError:
return False
def parse_csv(text: str, items: Dict[str, dict], max_rows: int = 2000) -> Tuple[List[dict], List[str]]:
"""Validate a cable CSV. Returns (cables, errors); nothing is applied on any error."""
reader = csv.DictReader(io.StringIO(text))
missing = [f for f in ('a_device',) if f not in (reader.fieldnames or [])]
if missing:
return [], [f'Missing column: {", ".join(missing)}']
rows, errors, labels = [], [], set()
for line, raw in enumerate(reader, start=2):
if line - 1 > max_rows:
errors.append(f'More than {max_rows} rows')
break
data = {k: (v or '').strip() for k, v in raw.items() if k}
for k in list(data):
if data[k].startswith("'") and data[k][1:2] in ('=', '+', '-', '@'):
data[k] = data[k][1:]
if not any(data.values()):
continue
data['label_applied'] = data.get('label_applied', '').lower() in ('yes', 'true', '1', 'y')
try:
cable = validate_cable(data, items)
except ValidationError as e:
errors.append(f'Line {line}: {e}')
continue
if cable['label']:
if cable['label'].lower() in labels:
errors.append(f'Line {line}: label {cable["label"]} appears twice')
continue
labels.add(cable['label'].lower())
rows.append(cable)
return rows, errors
# ── Problems, for the monitor ───────────────────────────────────────────────
def path_text(hops: list) -> str:
return ' → '.join(describe_node(h) for h in hops if not isinstance(h, int))
def runs_for(device: str, cables: List[dict], items: Dict[str, dict], switches: dict,
port: Optional[str] = None) -> List[dict]:
"""The live cables ending on a device (or one of its ports), each with its full run.
Returns [{'cable_id', 'label', 'port', 'status', 'verdict', 'detail', 'path'}].
"""
results = None
out = []
for c in sorted(cables, key=lambda c: _natural(c.get('label') or '')):
if not _live(c):
continue
for end in ('a', 'b'):
if not _same(device_of(c.get(f'{end}_device') or '', items), device):
continue
if port is not None and str(c.get(f'{end}_port') or '') != str(port):
continue
if results is None:
results = evaluate(cables, items, switches or {})
r = results[c['id']]
out.append({
'cable_id': c['id'], 'label': c.get('label') or f'#{c["id"]}',
'port': c.get(f'{end}_port') or '', 'status': c['status'],
'verdict': r['verdict'], 'detail': r['detail'], 'path': path_text(r['path']['hops']),
})
return out
def problems(cables: List[dict], items: Dict[str, dict], switches: dict) -> List[dict]:
"""One entry per installed run whose check found a problem.
A run through a panel is several cables with the same verdict; it is reported
once, under the cable on the switch port (the one people look for).
Returns [{'key', 'cable_id', 'label', 'switch', 'port', 'verdict', 'detail', 'path'}].
"""
switches = switches or {}
results = evaluate(cables, items, switches)
by_id = {c['id']: c for c in cables}
seen_runs = set()
found = []
for cid, r in sorted(results.items()):
if r['verdict'] not in PROBLEM_VERDICTS or by_id[cid]['status'] != 'installed':
continue
run = tuple(sorted(r['path']['cable_ids']))
if run in seen_runs and r['verdict'] != 'conflict':
continue
seen_runs.add(run)
hops = r['path']['hops']
ends = [n for n in (hops[0], hops[-1]) if n and n[0] in switches]
switch_end = ends[0] if ends else _node(by_id[cid], 'a')
# Name the run after the cable plugged into the switch, when there is one
lead = next((by_id[i] for i in r['path']['cable_ids']
if switch_end in (_node(by_id[i], 'a'), _node(by_id[i], 'b'))), by_id[cid])
if r['verdict'] == 'conflict':
lead = by_id[cid]
found.append({
'key': f'cable {lead["id"]}',
'cable_id': lead['id'],
'label': lead.get('label') or f'#{lead["id"]}',
'switch': switch_end[0] if switch_end else lead['a_device'],
'port': switch_end[1] if switch_end else lead['a_port'],
'verdict': r['verdict'],
'detail': r['detail'],
'path': path_text(hops),
})
return found
# ── Rack elevation ──────────────────────────────────────────────────────────
def _sides(item: dict) -> Tuple[str, ...]:
mount = item.get('mount') or 'front'
return ('front', 'rear') if mount == 'full' else (mount,)
def rack_layout(items: List[dict], units: int, face: str = 'front') -> dict:
"""Place items that have a rack unit, top of the rack first, as seen from one face.
Front and rear items may share a unit; full-depth items take it on both sides.
An item that would share a unit and side with one already placed, or runs past the
top of the rack, is reported (whichever face is asked for) rather than drawn over another.
Returns {'placed': [item + 'rack_top' + 'through'], 'overlaps': [{'name', 'units', 'with'}],
'outside': [name]}, where 'through' marks a full-depth item seen from the side it isn't faced to
(its back, for the rear view).
"""
taken: Dict[tuple, str] = {}
placed, overlaps, outside = [], [], []
racked = [i for i in items if i.get('rack_u')]
# Top first; where two claim the same top unit, the one recorded first is drawn
for item in sorted(racked, key=lambda i: (-(i['rack_u'] + (i.get('rack_height') or 1)), i.get('id') or 0)):
low = item['rack_u']
high = low + (item.get('rack_height') or 1) - 1
span = f'U{low}' if high == low else f'U{low}-{high}'
if high > units:
outside.append({'name': item['name'], 'units': span})
continue
sides = _sides(item)
cells = [(u, s) for u in range(low, high + 1) for s in sides]
clash = sorted({taken[c] for c in cells if c in taken})
if clash:
overlaps.append({'name': item['name'], 'units': span, 'with': clash})
continue
for c in cells:
taken[c] = item['name']
if face in sides:
placed.append(dict(item, rack_top=high, through=item.get('mount') == 'full' and face == 'rear'))
return {'placed': placed, 'overlaps': overlaps, 'outside': outside}
_MARK_RANK = {'bad': 3, 'doc': 2, 'ok': 1}
def port_marks(cables: List[dict]) -> Dict[tuple, dict]:
"""Per (device, port): the worst check of the live cables plugged in there.
`cables` are evaluated cables (with 'verdict', 'detail' and 'run', the IDs of
every cable in its run). Returns {(device, port): {'mark', 'text', 'cable_id', 'run'}},
where mark is ok (matches), bad (a problem) or doc (documented, not confirmed).
"""
out: Dict[tuple, dict] = {}
for c in cables:
if not _live(c):
continue
mark = 'bad' if c['verdict'] in PROBLEM_VERDICTS else ('ok' if c['verdict'] == 'match' else 'doc')
label = c.get('label') or f'#{c["id"]}'
for end in ('a', 'b'):
device, port = c.get(f'{end}_device'), c.get(f'{end}_port')
if not device or not port:
continue
entry = out.setdefault((device, str(port)), {'mark': mark, 'cable_id': c['id'], 'run': [], 'by_detail': {}})
if _MARK_RANK[mark] > _MARK_RANK[entry['mark']]:
entry.update(mark=mark, cable_id=c['id'])
entry['by_detail'].setdefault(c['detail'], []).append(label)
entry['run'] = sorted(set(entry['run']) | set(c.get('run') or [c['id']]))
for entry in out.values():
# A panel port's front and rear cables share one check: say it once
entry['text'] = '; '.join(f'cable{"s" if len(labels) > 1 else ""} {", ".join(labels)}: {detail}'
for detail, labels in entry.pop('by_detail').items())
return out
def validate_rack(data: dict) -> dict:
"""A rack from the rack settings form."""
rack = {
'name': _text(data, 'name', RACK_NAME_MAX, required=True, label='Rack name'),
'units': _int(data, 'units', 1, RACK_UNITS_MAX, 'Height'),
'notes': _text(data, 'notes', NOTES_MAX),
}
if not rack['units']:
raise ValidationError('Set the rack height in units')
return rack
+623
View File
@@ -178,6 +178,17 @@ def resolve_event(event_type: str, target_name: str, target_detail: str = '') ->
)
def get_open_event_targets(event_type: str) -> list:
"""(target_name, target_detail) of each unresolved event of one type."""
with get_conn() as conn:
with conn.cursor() as cur:
cur.execute(
'SELECT target_name, target_detail FROM network_events WHERE event_type=%s AND resolved_at IS NULL',
(event_type,),
)
return [(r['target_name'], r['target_detail']) for r in cur.fetchall()]
def set_ticket_id(event_id: int, ticket_id: str) -> None:
with get_conn() as conn:
with conn.cursor() as cur:
@@ -337,6 +348,175 @@ def cleanup_expired_suppressions() -> int:
return n
def ensure_events_schema() -> None:
"""Add columns newer than the original events table, so deploys need no manual migration."""
with get_conn() as conn:
with conn.cursor() as cur:
cur.execute("SHOW COLUMNS FROM network_events LIKE 'recovery_notified'")
if cur.fetchone():
return
cur.execute(
'ALTER TABLE network_events ADD COLUMN recovery_notified TINYINT(1) NOT NULL DEFAULT 0'
)
# Events that cleared before this existed are history, not owed a comment
cur.execute(
'UPDATE network_events SET recovery_notified=1, last_seen=last_seen WHERE resolved_at IS NOT NULL'
)
def get_pending_recovery_notes(hours: int = 24, exclude_types: tuple = ()) -> list:
"""Resolved events with a ticket whose recovery comment hasn't been posted yet."""
sql = """SELECT id, event_type, target_name, target_detail, ticket_id,
first_seen, resolved_at, consecutive_failures
FROM network_events
WHERE resolved_at IS NOT NULL AND ticket_id IS NOT NULL AND recovery_notified=0
AND resolved_at > DATE_SUB(NOW(), INTERVAL %s HOUR)"""
params: list = [hours]
if exclude_types:
sql += f' AND event_type NOT IN ({", ".join(["%s"] * len(exclude_types))})' # nosec B608 - placeholders only
params.extend(exclude_types)
with get_conn() as conn:
with conn.cursor() as cur:
cur.execute(sql + ' ORDER BY resolved_at', params)
return list(cur.fetchall())
def mark_recovery_notified(event_id: int) -> None:
with get_conn() as conn:
with conn.cursor() as cur:
# last_seen updates itself on any write; keep it as the last failing check
cur.execute(
'UPDATE network_events SET recovery_notified=1, last_seen=last_seen WHERE id=%s',
(event_id,),
)
def event_stats(event_type: str, target_name: str, target_detail: str = '') -> dict:
"""How often one alert has fired before, for a ticket's history section.
Returns {'last_7d', 'last_30d', 'last_first_seen', 'last_resolved_at'} over resolved events.
"""
key = (event_type, target_name, target_detail or '')
with get_conn() as conn:
with conn.cursor() as cur:
cur.execute(
"""SELECT COALESCE(SUM(first_seen > DATE_SUB(NOW(), INTERVAL 7 DAY)), 0) AS last_7d,
COUNT(*) AS last_30d
FROM network_events
WHERE event_type=%s AND target_name=%s AND target_detail=%s
AND resolved_at IS NOT NULL AND first_seen > DATE_SUB(NOW(), INTERVAL 30 DAY)""",
key,
)
counts = cur.fetchone() or {}
cur.execute(
"""SELECT first_seen, resolved_at FROM network_events
WHERE event_type=%s AND target_name=%s AND target_detail=%s
AND resolved_at IS NOT NULL ORDER BY resolved_at DESC LIMIT 1""",
key,
)
last = cur.fetchone() or {}
return {
'last_7d': int(counts.get('last_7d') or 0),
'last_30d': int(counts.get('last_30d') or 0),
'last_first_seen': last.get('first_seen'),
'last_resolved_at': last.get('resolved_at'),
}
def _history_where(since_hours: int, event_type: str = '', target: str = '',
severity: str = '', status: str = 'all') -> tuple:
"""WHERE clause shared by the history list and its summaries.
An event is in range if it was open at any point in the window: it started
in it, or it was still open when the window began.
"""
clauses = ['(first_seen > DATE_SUB(NOW(), INTERVAL %s HOUR) OR '
'resolved_at IS NULL OR resolved_at > DATE_SUB(NOW(), INTERVAL %s HOUR))']
params: list = [since_hours, since_hours]
if event_type:
clauses.append('event_type=%s')
params.append(event_type)
if severity:
clauses.append('severity=%s')
params.append(severity)
if target:
like = '%' + target.replace('\\', '\\\\').replace('%', '\\%').replace('_', '\\_') + '%'
clauses.append('(target_name LIKE %s OR target_detail LIKE %s)')
params.extend([like, like])
if status == 'active':
clauses.append('resolved_at IS NULL')
elif status == 'resolved':
clauses.append('resolved_at IS NOT NULL')
return ' AND '.join(clauses), params
def _iso(rows: list, keys=('first_seen', 'last_seen', 'resolved_at')) -> list:
for r in rows:
for k in keys:
if r.get(k) and hasattr(r[k], 'isoformat'):
r[k] = r[k].isoformat() + 'Z'
return rows
def get_events_history(since_hours: int, event_type: str = '', target: str = '', severity: str = '',
status: str = 'all', limit: int = 100, offset: int = 0) -> dict:
"""Events open at any time in the last `since_hours`, newest first, with totals.
Returns {'events', 'total', 'by_type': {type: count}}.
"""
where, params = _history_where(since_hours, event_type, target, severity, status)
with get_conn() as conn:
with conn.cursor() as cur:
cur.execute(
f"""SELECT id, event_type, severity, source_type, target_name, target_detail, description,
first_seen, last_seen, resolved_at, consecutive_failures, ticket_id,
TIMESTAMPDIFF(SECOND, first_seen, COALESCE(resolved_at, NOW())) AS duration_s
FROM network_events WHERE {where}
ORDER BY first_seen DESC, id DESC LIMIT %s OFFSET %s""", # nosec B608 - fixed clauses
params + [limit, offset],
)
events = _iso(list(cur.fetchall()))
cur.execute(
f"""SELECT event_type, COUNT(*) AS n
FROM network_events WHERE {where} GROUP BY event_type ORDER BY n DESC""", # nosec B608
params,
)
groups = cur.fetchall()
return {
'events': events,
'total': sum(int(g['n']) for g in groups),
'by_type': {g['event_type']: int(g['n']) for g in groups},
}
def get_flappers(since_hours: int, event_type: str = '', target: str = '', severity: str = '',
min_count: int = 2, limit: int = 10) -> list:
"""The alerts that fired most often in the window: the ones worth a root cause."""
where, params = _history_where(since_hours, event_type, target, severity)
with get_conn() as conn:
with conn.cursor() as cur:
cur.execute(
f"""SELECT event_type, target_name, target_detail, COUNT(*) AS n,
SUM(TIMESTAMPDIFF(SECOND, first_seen, COALESCE(resolved_at, NOW()))) AS total_s,
MAX(first_seen) AS last_seen, SUM(resolved_at IS NULL) AS open_now
FROM network_events WHERE {where}
GROUP BY event_type, target_name, target_detail
HAVING n >= %s ORDER BY n DESC, last_seen DESC LIMIT %s""", # nosec B608 - fixed clauses
params + [min_count, limit],
)
rows = list(cur.fetchall())
for r in rows:
r['n'], r['total_s'], r['open_now'] = int(r['n']), int(r['total_s'] or 0), int(r['open_now'] or 0)
return _iso(rows, ('last_seen',))
def get_event_types() -> list:
with get_conn() as conn:
with conn.cursor() as cur:
cur.execute('SELECT DISTINCT event_type FROM network_events ORDER BY event_type')
return [r['event_type'] for r in cur.fetchall()]
def purge_old_resolved_events(days: int = 90) -> int:
"""Delete resolved events older than `days` days. Returns count deleted."""
with get_conn() as conn:
@@ -478,3 +658,446 @@ def is_suppressed(target_type: str, target_name: str, target_detail: str = '') -
return True
return False
# ---------------------------------------------------------------------------
# Cutsheets (see cutsheet.py). Every change writes a cutsheet_history row in
# the same transaction, so the log can't miss an edit.
# ---------------------------------------------------------------------------
_CUTSHEET_SCHEMA = (
"""CREATE TABLE IF NOT EXISTS cutsheet_items (
id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(100) NOT NULL,
kind VARCHAR(20) NOT NULL,
port_count SMALLINT NULL,
location VARCHAR(255) NOT NULL DEFAULT '',
rack_u SMALLINT NULL,
rack_height SMALLINT NULL,
rack VARCHAR(100) NOT NULL DEFAULT '',
shelf VARCHAR(100) NOT NULL DEFAULT '',
device VARCHAR(255) NOT NULL DEFAULT '',
mount VARCHAR(10) NOT NULL DEFAULT 'front',
chassis VARCHAR(40) NOT NULL DEFAULT '',
notes TEXT NULL,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
UNIQUE KEY uq_item_name (name)
) ENGINE=InnoDB""",
"""CREATE TABLE IF NOT EXISTS cutsheet_cables (
id INT AUTO_INCREMENT PRIMARY KEY,
label VARCHAR(32) NULL,
a_device VARCHAR(100) NOT NULL,
a_port VARCHAR(64) NOT NULL DEFAULT '',
a_side VARCHAR(5) NOT NULL DEFAULT '',
b_device VARCHAR(100) NOT NULL DEFAULT '',
b_port VARCHAR(64) NOT NULL DEFAULT '',
b_side VARCHAR(5) NOT NULL DEFAULT '',
cable_type VARCHAR(32) NOT NULL DEFAULT '',
length_m DECIMAL(5,2) NULL,
color VARCHAR(32) NOT NULL DEFAULT '',
status VARCHAR(10) NOT NULL DEFAULT 'installed',
label_applied BOOLEAN NOT NULL DEFAULT FALSE,
notes TEXT NULL,
created_by VARCHAR(255) NOT NULL DEFAULT '',
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_by VARCHAR(255) NOT NULL DEFAULT '',
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
UNIQUE KEY uq_cable_label (label),
INDEX idx_cable_a (a_device, a_port),
INDEX idx_cable_b (b_device, b_port)
) ENGINE=InnoDB""",
"""CREATE TABLE IF NOT EXISTS cutsheet_port_labels (
item_id INT NOT NULL,
port VARCHAR(64) NOT NULL,
label VARCHAR(64) NOT NULL DEFAULT '',
applied BOOLEAN NOT NULL DEFAULT FALSE,
PRIMARY KEY (item_id, port)
) ENGINE=InnoDB""",
"""CREATE TABLE IF NOT EXISTS cutsheet_history (
id INT AUTO_INCREMENT PRIMARY KEY,
changed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
changed_by VARCHAR(255) NOT NULL,
entity VARCHAR(12) NOT NULL,
entity_id INT NOT NULL,
action VARCHAR(10) NOT NULL,
summary VARCHAR(500) NOT NULL,
before_json TEXT NULL,
after_json TEXT NULL,
INDEX idx_hist_time (changed_at),
INDEX idx_hist_entity (entity, entity_id)
) ENGINE=InnoDB""",
"""CREATE TABLE IF NOT EXISTS cutsheet_racks (
id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(100) NOT NULL,
units SMALLINT NOT NULL,
notes TEXT NULL,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
UNIQUE KEY uq_rack_name (name)
) ENGINE=InnoDB""",
# Where a device lives in the asset inventory (HomeBox), set by hand on its Gandalf page
"""CREATE TABLE IF NOT EXISTS device_links (
name VARCHAR(255) NOT NULL PRIMARY KEY,
inventory_url VARCHAR(512) NOT NULL,
updated_by VARCHAR(255) NOT NULL,
updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB""",
)
def get_device_link(name: str) -> str:
"""The device's inventory URL, or ''."""
with get_conn() as conn:
with conn.cursor() as cur:
cur.execute('SELECT inventory_url FROM device_links WHERE name=%s', (name,))
row = cur.fetchone()
return row['inventory_url'] if row else ''
def set_device_link(name: str, inventory_url: str, user: str) -> None:
"""Save a device's inventory URL; an empty URL removes it."""
with get_conn() as conn:
with conn.cursor() as cur:
if not inventory_url:
cur.execute('DELETE FROM device_links WHERE name=%s', (name,))
return
cur.execute(
"""INSERT INTO device_links (name, inventory_url, updated_by) VALUES (%s, %s, %s)
ON DUPLICATE KEY UPDATE inventory_url=VALUES(inventory_url), updated_by=VALUES(updated_by)""",
(name, inventory_url, user),
)
_ITEM_FIELDS = ('name', 'kind', 'port_count', 'location', 'rack_u', 'rack_height', 'rack', 'shelf', 'device',
'mount', 'chassis', 'notes')
# Columns added to cutsheet_items after its first release: (name, definition)
_ITEM_COLUMNS_ADDED = (
('rack', "VARCHAR(100) NOT NULL DEFAULT ''"),
('shelf', "VARCHAR(100) NOT NULL DEFAULT ''"),
# The Gandalf device (UniFi or host name) an item is, when its own name differs
('device', "VARCHAR(255) NOT NULL DEFAULT ''"),
('mount', "VARCHAR(10) NOT NULL DEFAULT 'front'"),
('chassis', "VARCHAR(40) NOT NULL DEFAULT ''"),
)
_CABLE_FIELDS = ('label', 'a_device', 'a_port', 'a_side', 'b_device', 'b_port', 'b_side',
'cable_type', 'length_m', 'color', 'status', 'label_applied', 'notes')
class CutsheetConflict(Exception):
"""A change that would clash with existing records (duplicate name or label, item in use)."""
def ensure_cutsheet_schema() -> None:
with get_conn() as conn:
with conn.cursor() as cur:
for statement in _CUTSHEET_SCHEMA:
cur.execute(statement)
cur.execute('SHOW COLUMNS FROM cutsheet_items')
have = {r['Field'] for r in cur.fetchall()}
for column, definition in _ITEM_COLUMNS_ADDED:
if column not in have:
# Fixed names from _ITEM_COLUMNS_ADDED, never user input
cur.execute(f'ALTER TABLE cutsheet_items ADD COLUMN {column} {definition}') # nosec B608
def _cs_jsonable(row: Optional[dict]) -> Optional[dict]:
if row is None:
return None
out = {}
for k, v in row.items():
if hasattr(v, 'isoformat'):
v = v.isoformat() + 'Z'
elif v is not None and k == 'length_m':
v = float(v)
elif k in ('label_applied', 'applied'):
v = bool(v)
out[k] = v
return out
def _cs_log(cur, user: str, entity: str, entity_id: int, action: str, summary: str,
before: Optional[dict], after: Optional[dict]) -> None:
cur.execute(
"""INSERT INTO cutsheet_history (changed_by, entity, entity_id, action, summary, before_json, after_json)
VALUES (%s, %s, %s, %s, %s, %s, %s)""",
(user, entity, entity_id, action, summary[:500],
json.dumps(_cs_jsonable(before)) if before else None,
json.dumps(_cs_jsonable(after)) if after else None),
)
@contextmanager
def _cs_transaction():
with get_conn() as conn:
conn.begin()
try:
with conn.cursor() as cur:
yield cur
conn.commit()
except pymysql.err.IntegrityError as e:
conn.rollback()
raise CutsheetConflict(_cs_integrity_message(e)) from e
except Exception:
conn.rollback()
raise
def _cs_integrity_message(e: Exception) -> str:
text = str(e)
if 'uq_cable_label' in text:
return 'Another cable already has that label'
if 'uq_item_name' in text:
return 'Another item already has that name'
return 'That change conflicts with an existing record'
def cutsheet_load() -> dict:
"""Every cutsheet record, for one page render or API response."""
with get_conn() as conn:
with conn.cursor() as cur:
cur.execute('SELECT * FROM cutsheet_items ORDER BY name')
items = [_cs_jsonable(r) for r in cur.fetchall()]
cur.execute('SELECT * FROM cutsheet_cables ORDER BY id')
cables = [_cs_jsonable(r) for r in cur.fetchall()]
cur.execute(
"""SELECT l.item_id, i.name AS item_name, l.port, l.label, l.applied
FROM cutsheet_port_labels l JOIN cutsheet_items i ON i.id = l.item_id"""
)
port_labels = [_cs_jsonable(r) for r in cur.fetchall()]
return {'items': items, 'cables': cables, 'port_labels': port_labels}
def cutsheet_history(limit: int = 100) -> list:
with get_conn() as conn:
with conn.cursor() as cur:
cur.execute(
"""SELECT id, changed_at, changed_by, entity, entity_id, action, summary
FROM cutsheet_history ORDER BY id DESC LIMIT %s""",
(limit,),
)
return [_cs_jsonable(r) for r in cur.fetchall()]
def _cs_get(cur, table: str, row_id: int) -> Optional[dict]:
cur.execute(f'SELECT * FROM {table} WHERE id=%s FOR UPDATE', (row_id,)) # nosec B608 (fixed names)
return cur.fetchone()
def cutsheet_create_item(item: dict, user: str) -> int:
with _cs_transaction() as cur:
cur.execute(
f'INSERT INTO cutsheet_items ({", ".join(_ITEM_FIELDS)}) ' # nosec B608 (fixed names)
f'VALUES ({", ".join(["%s"] * len(_ITEM_FIELDS))})',
tuple(item[f] for f in _ITEM_FIELDS),
)
item_id = cur.lastrowid
_cs_log(cur, user, 'item', item_id, 'create', f'Added {item["kind"]} {item["name"]}', None, item)
return item_id
def cutsheet_update_item(item_id: int, item: dict, user: str) -> bool:
"""Update an item. A rename carries over to the cables that reference it."""
with _cs_transaction() as cur:
before = _cs_get(cur, 'cutsheet_items', item_id)
if before is None:
return False
cur.execute(
f'UPDATE cutsheet_items SET {", ".join(f"{f}=%s" for f in _ITEM_FIELDS)} WHERE id=%s', # nosec B608
tuple(item[f] for f in _ITEM_FIELDS) + (item_id,),
)
summary = f'Edited {item["name"]}'
if before['kind'] == 'shelf' and item['kind'] != 'shelf':
on_it = _cs_on_shelf(cur, before['name'])
if on_it:
raise CutsheetConflict(f'{before["name"]} still holds {on_it} item(s); move them off the shelf first')
if before['name'] != item['name']:
for end in ('a', 'b'):
cur.execute(
f'UPDATE cutsheet_cables SET {end}_device=%s, updated_by=%s WHERE {end}_device=%s', # nosec B608
(item['name'], user, before['name']),
)
cur.execute('UPDATE cutsheet_items SET shelf=%s WHERE shelf=%s', (item['name'], before['name']))
summary = f'Renamed {before["name"]} to {item["name"]}'
_cs_log(cur, user, 'item', item_id, 'update', summary, before, item)
return True
def _cs_on_shelf(cur, shelf: str) -> int:
cur.execute('SELECT COUNT(*) AS n FROM cutsheet_items WHERE shelf=%s', (shelf,))
return cur.fetchone()['n']
def cutsheet_delete_item(item_id: int, user: str) -> bool:
with _cs_transaction() as cur:
before = _cs_get(cur, 'cutsheet_items', item_id)
if before is None:
return False
cur.execute(
'SELECT COUNT(*) AS n FROM cutsheet_cables WHERE a_device=%s OR b_device=%s',
(before['name'], before['name']),
)
used = cur.fetchone()['n']
if used:
raise CutsheetConflict(f'{before["name"]} still has {used} cable(s); move or delete them first')
on_it = _cs_on_shelf(cur, before['name'])
if on_it:
raise CutsheetConflict(f'{before["name"]} still holds {on_it} item(s); move them off the shelf first')
cur.execute('DELETE FROM cutsheet_port_labels WHERE item_id=%s', (item_id,))
cur.execute('DELETE FROM cutsheet_items WHERE id=%s', (item_id,))
_cs_log(cur, user, 'item', item_id, 'delete', f'Removed {before["name"]}', before, None)
return True
def _cable_summary(c: dict) -> str:
def end(device: str, port: str) -> str:
return ' '.join(filter(None, [device or 'unterminated', port]))
ends = f'{end(c["a_device"], c["a_port"])} ↔ {end(c["b_device"], c["b_port"])}'
return f'{c.get("label") or "unlabeled cable"}: {ends}'
def cutsheet_create_cable(cable: dict, user: str) -> int:
with _cs_transaction() as cur:
cur.execute(
f'INSERT INTO cutsheet_cables ({", ".join(_CABLE_FIELDS)}, created_by, updated_by) ' # nosec B608
f'VALUES ({", ".join(["%s"] * len(_CABLE_FIELDS))}, %s, %s)',
tuple(cable[f] for f in _CABLE_FIELDS) + (user, user),
)
cable_id = cur.lastrowid
_cs_log(cur, user, 'cable', cable_id, 'create', f'Added {_cable_summary(cable)}', None, cable)
return cable_id
def cutsheet_update_cable(cable_id: int, cable: dict, user: str) -> bool:
with _cs_transaction() as cur:
before = _cs_get(cur, 'cutsheet_cables', cable_id)
if before is None:
return False
cur.execute(
f'UPDATE cutsheet_cables SET {", ".join(f"{f}=%s" for f in _CABLE_FIELDS)}, updated_by=%s ' # nosec B608
'WHERE id=%s',
tuple(cable[f] for f in _CABLE_FIELDS) + (user, cable_id),
)
_cs_log(cur, user, 'cable', cable_id, 'update', f'Edited {_cable_summary(cable)}', before, cable)
return True
def cutsheet_delete_cable(cable_id: int, user: str) -> bool:
with _cs_transaction() as cur:
before = _cs_get(cur, 'cutsheet_cables', cable_id)
if before is None:
return False
cur.execute('DELETE FROM cutsheet_cables WHERE id=%s', (cable_id,))
_cs_log(cur, user, 'cable', cable_id, 'delete', f'Deleted {_cable_summary(before)}', before, None)
return True
def cutsheet_set_port_label(item_id: int, port: str, label: str, applied: bool, user: str) -> bool:
with _cs_transaction() as cur:
item = _cs_get(cur, 'cutsheet_items', item_id)
if item is None:
return False
cur.execute('SELECT * FROM cutsheet_port_labels WHERE item_id=%s AND port=%s', (item_id, port))
before = cur.fetchone()
if label:
cur.execute(
"""INSERT INTO cutsheet_port_labels (item_id, port, label, applied) VALUES (%s, %s, %s, %s)
ON DUPLICATE KEY UPDATE label=VALUES(label), applied=VALUES(applied)""",
(item_id, port, label, applied),
)
else:
cur.execute('DELETE FROM cutsheet_port_labels WHERE item_id=%s AND port=%s', (item_id, port))
after = {'item_id': item_id, 'port': port, 'label': label, 'applied': applied} if label else None
_cs_log(cur, user, 'port_label', item_id, 'update',
f'{item["name"]} port {port} label: {label or "(cleared)"}', before, after)
return True
def cutsheet_import_cables(cables: list, user: str) -> dict:
"""Add or update cables from a CSV import, matching on label. All or nothing."""
added = updated = 0
with _cs_transaction() as cur:
for cable in cables:
before = None
if cable['label']:
cur.execute('SELECT * FROM cutsheet_cables WHERE label=%s FOR UPDATE', (cable['label'],))
before = cur.fetchone()
if before:
cur.execute(
f'UPDATE cutsheet_cables SET {", ".join(f"{f}=%s" for f in _CABLE_FIELDS)}, ' # nosec B608
'updated_by=%s WHERE id=%s',
tuple(cable[f] for f in _CABLE_FIELDS) + (user, before['id']),
)
_cs_log(cur, user, 'cable', before['id'], 'update', f'Imported {_cable_summary(cable)}',
before, cable)
updated += 1
else:
cur.execute(
f'INSERT INTO cutsheet_cables ({", ".join(_CABLE_FIELDS)}, created_by, updated_by) ' # nosec
f'VALUES ({", ".join(["%s"] * len(_CABLE_FIELDS))}, %s, %s)',
tuple(cable[f] for f in _CABLE_FIELDS) + (user, user),
)
_cs_log(cur, user, 'cable', cur.lastrowid, 'create', f'Imported {_cable_summary(cable)}',
None, cable)
added += 1
return {'added': added, 'updated': updated}
# ---------------------------------------------------------------------------
# Racks (cutsheet_racks): name and height, edited on the rack page
# ---------------------------------------------------------------------------
def cutsheet_racks() -> list:
with get_conn() as conn:
with conn.cursor() as cur:
cur.execute('SELECT id, name, units, notes FROM cutsheet_racks ORDER BY id')
return list(cur.fetchall())
def cutsheet_save_rack(rack_id: Optional[int], rack: dict, user: str, previous: str = '') -> int:
"""Create (rack_id None) or update a rack. A rename carries over to the items in it.
`previous` names the rack being replaced when the first rack is saved for the first
time (it existed only as the default until then), so its items follow the new name.
"""
with _cs_transaction() as cur:
before = None
if rack_id is not None:
cur.execute('SELECT * FROM cutsheet_racks WHERE id=%s', (rack_id,))
before = cur.fetchone()
if before is None:
raise CutsheetConflict('No such rack')
cur.execute('SELECT name FROM cutsheet_racks WHERE LOWER(name)=LOWER(%s) AND id<>%s',
(rack['name'], rack_id or 0))
clash = cur.fetchone()
if clash:
raise CutsheetConflict(f'A rack named {clash["name"]} already exists')
if before is None:
cur.execute('INSERT INTO cutsheet_racks (name, units, notes) VALUES (%s, %s, %s)',
(rack['name'], rack['units'], rack['notes']))
rack_id = cur.lastrowid
old_name = previous
else:
cur.execute('UPDATE cutsheet_racks SET name=%s, units=%s, notes=%s WHERE id=%s',
(rack['name'], rack['units'], rack['notes'], rack_id))
old_name = before['name']
if old_name and old_name != rack['name']:
cur.execute('UPDATE cutsheet_items SET rack=%s WHERE rack=%s', (rack['name'], old_name))
renamed = f' (was {old_name})' if old_name and old_name != rack['name'] else ''
_cs_log(cur, user, 'rack', rack_id, 'update' if before else 'create',
f'Rack {rack["name"]}: {rack["units"]}U{renamed}', _cs_jsonable(before), rack)
return rack_id
def cutsheet_delete_rack(rack_id: int, user: str) -> bool:
with _cs_transaction() as cur:
cur.execute('SELECT * FROM cutsheet_racks WHERE id=%s', (rack_id,))
before = cur.fetchone()
if before is None:
return False
cur.execute('SELECT COUNT(*) AS n FROM cutsheet_items WHERE rack=%s', (before['name'],))
n = cur.fetchone()['n']
if n:
raise CutsheetConflict(f'{before["name"]} still holds {n} item(s); move them to another rack first')
cur.execute('DELETE FROM cutsheet_racks WHERE id=%s', (rack_id,))
_cs_log(cur, user, 'rack', rack_id, 'delete', f'Removed rack {before["name"]}', _cs_jsonable(before), None)
return True
+12 -12
View File
@@ -1,4 +1,4 @@
"""Gandalf – Link Diagnostics module.
"""Gandalf: Link Diagnostics module.
Runs a comprehensive SSH-based diagnostic against a server NIC and
analyses the result against switch port data to surface root causes.
@@ -475,7 +475,7 @@ class DiagnosticsRunner:
# Physical carrier
if carrier == '0':
add(issues, 'NO_CARRIER',
'No physical carrier — cable/SFP disconnected or switch port disabled')
'No physical carrier: cable/SFP disconnected or switch port disabled')
elif eth.get('link_detected') is False and carrier != '0':
add(issues, 'LINK_NOT_DETECTED',
'NIC does not detect link signal despite carrier sysfs reading non-zero')
@@ -483,7 +483,7 @@ class DiagnosticsRunner:
# Duplex
if eth.get('duplex') == 'half':
add(issues, 'HALF_DUPLEX',
'Half-duplex detected — likely duplex mismatch; force full-duplex on both ends')
'Half-duplex detected: likely duplex mismatch; force full-duplex on both ends')
# Speed mismatch (switch vs server NIC)
sw_speed = switch_port_data.get('speed_mbps', 0) or 0
@@ -498,31 +498,31 @@ class DiagnosticsRunner:
if rx_dbm is not None:
if rx_dbm < -25:
add(issues, 'SFP_RX_CRITICAL',
f'RX power critically low ({rx_dbm:.2f} dBm) — fiber not connected or SFP failed')
f'RX power critically low ({rx_dbm:.2f} dBm): fiber not connected or SFP failed')
elif rx_dbm < -18:
add(warnings, 'SFP_RX_LOW',
f'RX power low ({rx_dbm:.2f} dBm) — check fiber cleanliness and SFP seating')
f'RX power low ({rx_dbm:.2f} dBm): check fiber cleanliness and SFP seating')
if tx_dbm is not None and tx_dbm < -10:
add(warnings, 'SFP_TX_LOW',
f'TX power low ({tx_dbm:.2f} dBm) — SFP may be failing or requires cleaning')
f'TX power low ({tx_dbm:.2f} dBm): SFP may be failing or requires cleaning')
# Carrier changes (flapping)
if cc is not None:
if cc > 100:
add(issues, 'CARRIER_FLAPPING',
f'Link has flapped {cc} times — severe physical instability')
f'Link has flapped {cc} times: severe physical instability')
elif cc > 20:
add(warnings, 'CARRIER_FLAPS',
f'Link has flapped {cc} times — intermittent physical issue')
f'Link has flapped {cc} times: intermittent physical issue')
# CRC errors
crc = sysfs.get('rx_crc_errors', 0) or 0
if crc > 100:
add(issues, 'CRC_ERRORS_HIGH',
f'High CRC error count ({crc}) — dirty fiber/connector or cable damage')
f'High CRC error count ({crc}): dirty fiber/connector or cable damage')
elif crc > 10:
add(warnings, 'CRC_ERRORS_LOW',
f'CRC errors present ({crc}) — cable or SFP quality issue')
f'CRC errors present ({crc}): cable or SFP quality issue')
# Kernel events
err_events = [e for e in dmesg if e['severity'] == 'error']
@@ -540,9 +540,9 @@ class DiagnosticsRunner:
if expected_switch and srv_neighbor and names_differ:
add(warnings, 'LLDP_MISMATCH',
f'LLDP mismatch: this port is on "{switch_port_data.get("switch_name")}" but the server\'s '
f'lldpctl sees "{lldp.get("neighbor_system")}" — cross-cabled port?')
f'lldpctl sees "{lldp.get("neighbor_system")}": cross-cabled port?')
else:
add(info, 'LLDP_MISSING',
'lldpd not running on server — install lldpd for full path validation')
'lldpd not running on server: install lldpd for full path validation')
return {'issues': issues, 'warnings': warnings, 'info': info}
+498 -126
View File
@@ -15,14 +15,16 @@ import statistics
import time
from datetime import datetime, timezone
from typing import Dict, List, Optional
from urllib.parse import urlparse
from urllib.parse import urljoin, urlparse
import requests
from urllib3.exceptions import InsecureRequestWarning
import db
import cutsheet
import devices
import modem as modem_api
import ticket_text
logging.basicConfig(
@@ -245,6 +247,68 @@ class UnifiClient:
logger.error(f'UniFi API error: {e}')
return None
@staticmethod
def _sfp_detail(port: dict) -> Optional[dict]:
"""The module in an SFP cage, or None for a port that has no cage.
Every cage reports whether a module is present and what it is. Optical
readings (DOM) only come from modules that report them, such as fibre
optics; copper DACs have none. Switches and the UDM spell the fault flags
differently.
"""
if 'sfp_found' not in port:
return None
if not port.get('sfp_found'):
return {'found': False}
def number(key: str) -> Optional[float]:
try:
return float(port[key])
except (KeyError, TypeError, ValueError):
return None
part = str(port.get('sfp_part') or '').strip()
compliance = str(port.get('sfp_compliance') or '').strip()
if compliance.lower() == 'unknown':
compliance = ''
rx_power = number('sfp_rxpower')
if 'DAC' in compliance.upper() or re.search(r'(^|[-_])CU\d', part, re.IGNORECASE):
kind = 'dac'
elif rx_power is not None or compliance:
kind = 'optic'
else:
kind = ''
return {
'found': True,
'kind': kind,
'vendor': str(port.get('sfp_vendor') or '').strip(),
'part': part,
'serial': str(port.get('sfp_serial') or '').strip(),
'compliance': compliance,
'rx_power_dbm': rx_power,
'tx_power_dbm': number('sfp_txpower'),
'temperature_c': number('sfp_temperature'),
'voltage_v': number('sfp_voltage'),
'current_ma': number('sfp_current'),
'rx_fault': bool(port.get('sfp_rxfault', port.get('sfp_rx_los', False))),
'tx_fault': bool(port.get('sfp_txfault', port.get('sfp_tx_fault', False))),
}
@staticmethod
def _pair_dac_ends(switches: Dict[str, dict]) -> None:
"""Link the two ends of each DAC cable: both report the cable's serial."""
ends: Dict[str, List[tuple]] = {}
for sw_name, sw in switches.items():
for port in sw['ports'].values():
sfp = port.get('sfp') or {}
if sfp.get('kind') == 'dac' and sfp.get('serial'):
ends.setdefault(sfp['serial'], []).append((sw_name, port))
for pair in ends.values():
if len(pair) != 2:
continue # one end not seen, or a serial that isn't unique
for (_, port), (peer_name, peer) in (pair, pair[::-1]):
port['sfp']['cable_peer'] = {'switch': peer_name, 'port_idx': peer['port_idx']}
def get_switch_ports(self) -> Optional[Dict[str, dict]]:
"""Return per-port stats for UniFi switches and routers, keyed by device name.
@@ -280,6 +344,11 @@ class UnifiClient:
for port in dev.get('port_table', []):
idx = port.get('port_idx', 0)
pname = port.get('name') or f'Port {idx}'
# Ports are keyed by name, and UniFi lets two ports share one
# (e.g. a stale label copied to the next port). Without this the
# later port silently replaced the earlier one.
if pname in ports:
pname = f'{pname} (Port {idx})'
raw_poe = port.get('poe_power')
raw_poe_max = port.get('poe_max_power')
ports[pname] = {
@@ -302,9 +371,11 @@ class UnifiClient:
'rx_errors': port.get('rx_errors', 0),
'tx_dropped': port.get('tx_dropped', 0),
'rx_dropped': port.get('rx_dropped', 0),
'sfp': self._sfp_detail(port),
}
if ports:
result[sw_name] = {'ip': sw_ip, 'model': sw_model, 'ports': ports}
self._pair_dac_ends(result)
return result
except Exception as e:
logger.error(f'UniFi switch port stats error: {e}')
@@ -318,10 +389,45 @@ class TicketClient:
def __init__(self, cfg: dict):
self.url = cfg.get('url', '')
self.api_key = cfg.get('api_key', '')
# Tinker serves its other API scripts under api/ beside create_ticket_api.php
self.comment_url = cfg.get('comment_url') or (
urljoin(self.url, 'api/ticket_comment_api.php') if self.url else '')
self.comments_denied = False
def comment(self, ticket_id: str, text: str) -> bool:
"""Add a Markdown comment to a ticket. Never raises; False means try again later."""
if not self.api_key or not self.comment_url or self.comments_denied:
return False
try:
resp = requests.post(
self.comment_url,
json={'ticket_id': str(ticket_id), 'comment_text': text, 'markdown_enabled': True},
headers={'Authorization': f'Bearer {self.api_key}'},
timeout=15,
)
if resp.status_code in (401, 403):
# Retrying every cycle can't fix a key without write access, so stop until restart
self.comments_denied = True
logger.error(
f'Ticket API refused a comment on #{ticket_id} (HTTP {resp.status_code}). '
f'The API key needs read_write scope; recovery notes are off until the monitor restarts.'
)
return False
if resp.status_code == 404:
logger.warning(f'Ticket #{ticket_id} no longer exists; skipping its recovery note')
return True
resp.raise_for_status()
if resp.json().get('success'):
logger.info(f'Commented on ticket #{ticket_id}')
return True
logger.warning(f'Unexpected comment API response for #{ticket_id}: {resp.text[:200]}')
except Exception as e:
logger.error(f'Ticket comment failed for #{ticket_id}: {e}')
return False
def create(self, title: str, description: str, priority: str = '2') -> Optional[str]:
if not self.api_key or not self.url:
logger.warning('Ticket API not configured – skipping ticket creation')
logger.warning('Ticket API not configured: skipping ticket creation')
return None
try:
resp = requests.post(
@@ -347,7 +453,7 @@ class TicketClient:
logger.info(f'Created ticket #{tid}: {title}')
return tid
if data.get('existing_ticket_id'):
logger.info(f'Duplicate suppressed by API – existing #{data["existing_ticket_id"]}')
logger.info(f'Duplicate suppressed by API: existing #{data["existing_ticket_id"]}')
return data['existing_ticket_id']
logger.warning(f'Unexpected ticket API response: {data}')
except Exception as e:
@@ -708,7 +814,7 @@ class LinkStatsCollector:
host = instance_map.get(instance, host_ip)
ifaces = list(iface_metrics.keys())
# SSH ethtool collection via Pulse worker — only for explicitly configured
# SSH ethtool collection via Pulse worker: only for explicitly configured
# hosts (instance_map keys). Hosts like postgresql/matrix may report
# node_exporter metrics to Prometheus but don't need link diagnostics.
ethtool_data: Dict[str, dict] = {}
@@ -786,7 +892,7 @@ class LinkStatsCollector:
dt = now - self._prev_unifi_time if self._prev_unifi_time > 0 else 0
def rate(new_val: int, old_val: Optional[int]) -> Optional[float]:
# No earlier reading (first poll, or a new/renamed port) means no rate,
# No earlier reading (first poll, or a newly reported port) means no rate,
# not "all bytes since boot arrived in this one interval".
if dt <= 0 or old_val is None:
return None
@@ -794,11 +900,16 @@ class LinkStatsCollector:
result: Dict[str, dict] = {}
for sw_name, sw_data in raw.items():
prev_ports = self._prev_unifi.get(sw_name, {}).get('ports', {})
# Match by port number: names are re-read from UniFi every poll, so a
# port renamed there keeps its rates instead of losing them for a cycle.
prev_ports = {
p.get('port_idx'): p
for p in self._prev_unifi.get(sw_name, {}).get('ports', {}).values()
}
merged_ports: Dict[str, dict] = {}
for pname, d in sw_data['ports'].items():
entry = dict(d)
prev = prev_ports.get(pname, {})
prev = prev_ports.get(d.get('port_idx'), {})
entry['tx_bytes_rate'] = rate(d['tx_bytes'], prev.get('tx_bytes'))
entry['rx_bytes_rate'] = rate(d['rx_bytes'], prev.get('rx_bytes'))
entry['tx_errs_rate'] = rate(d['tx_errors'], prev.get('tx_errors'))
@@ -818,10 +929,21 @@ def _now_utc() -> str:
return datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S UTC')
def _utcnow() -> datetime:
"""Naive UTC, to compare with database times."""
return datetime.now(timezone.utc).replace(tzinfo=None)
# --------------------------------------------------------------------------
# Monitor
# --------------------------------------------------------------------------
CLUSTER_NAME = 'proxmox-cluster'
DEFAULT_PUBLIC_URL = 'https://gandalf.lotusguild.org'
# Reports of something already over: the ticket is the whole story, no recovery note
ONE_SHOT_EVENTS = ('modem_power_cycled', 'wan_unstable')
# Ports a host or device was last seen on, kept so a ticket for a dead host
# (whose link, and so its LLDP entry, is gone) can still say where it plugs in
KNOWN_UPLINKS_STATE = 'known_uplinks'
class NetworkMonitor:
@@ -844,6 +966,10 @@ class NetworkMonitor:
# Use a separate, more forgiving threshold so those momentary reboots
# don't cut tickets, while still catching genuine device failures.
self.unifi_fail_thresh = mon.get('unifi_failure_threshold', self.fail_thresh)
# A host's exporter stops as soon as a shutdown begins and a normal reboot
# takes about 3-5 minutes, so wait longer than that before ticketing a host
# that has disappeared. A NIC going down on a running host stays on fail_thresh.
self.host_fail_thresh = mon.get('host_failure_threshold', 5)
self.cluster_thresh = mon.get('cluster_threshold', 3)
self.cluster_name = mon.get('cluster_name', CLUSTER_NAME)
@@ -865,6 +991,23 @@ class NetworkMonitor:
except Exception as e:
logger.error(f'Could not create modem history table: {e}')
# Cutsheet mismatches open a P4 ticket once they've lasted this long (0 = never ticket)
self.cutsheet_ticket_hours = (self.cfg.get('cutsheet') or {}).get('mismatch_ticket_hours', 24)
try:
db.ensure_cutsheet_schema()
except Exception as e:
logger.error(f'Could not create cutsheet tables: {e}')
try:
db.ensure_events_schema()
except Exception as e:
logger.error(f'Could not update the events table: {e}')
# Absolute links in tickets point here
self.public_url = ((self.cfg.get('gandalf') or {}).get('public_url')
or DEFAULT_PUBLIC_URL).rstrip('/')
self._link_data: Optional[dict] = None
self._known_uplinks: Optional[dict] = None
# Last good Prometheus result, shown (as unknown) during a Prometheus outage
self._last_iface_states: Dict[str, Dict[str, bool]] = {}
@@ -878,6 +1021,174 @@ class NetworkMonitor:
def _hostname(self, instance: str) -> str:
return self._instance_map.get(instance, instance.split(':')[0])
# ------------------------------------------------------------------
# Tickets: context, and notes when an alert clears
# ------------------------------------------------------------------
def _base_url(self) -> str:
return getattr(self, 'public_url', DEFAULT_PUBLIC_URL)
def _open_ticket(
self, event_id: int, event_type: str, target: str, detail: str, *,
title: str, heading: str, facts: list, summary: str, checks: list, priority: str,
host: Optional[str] = None, port: Optional[tuple] = None,
) -> None:
"""Open a ticket with the alert's facts plus everything Gandalf knows around it.
host: a device whose switch ports to list. port: (switch, port_idx) the alert is about.
"""
sections = self._ticket_sections(event_id, event_type, target, detail, host=host, port=port)
desc = ticket_text.description(heading, facts, summary, checks, sections)
tid = self.tickets.create(title, desc, priority=priority)
if tid:
db.set_ticket_id(event_id, tid)
def _ticket_sections(self, event_id: int, event_type: str, target: str, detail: str,
host: Optional[str] = None, port: Optional[tuple] = None) -> list:
"""Each section is optional: a failure loses that section, never the ticket."""
sections = []
for title, build in (
('Where it is connected', lambda: self._where_lines(event_type, detail, host, port)),
('History', lambda: ticket_text.history_lines(db.event_stats(event_type, target, detail), _utcnow())),
('Other active alerts here', lambda: self._other_alert_lines(event_id, {target, host})),
('Links', lambda: self._link_lines(host or (port[0] if port else None))),
):
try:
sections.append((title, build()))
except Exception as e:
logger.error(f'Ticket section "{title}" for {target} failed: {e}', exc_info=True)
return sections
def _switches(self) -> dict:
return (getattr(self, '_link_data', None) or {}).get('unifi_switches') or {}
def _remember_uplinks(self, link_data: dict) -> None:
"""Record where every LLDP-visible device is plugged in, for when it disappears."""
known = self._load_known_uplinks()
switches = link_data.get('unifi_switches') or {}
names = {(p.get('lldp') or {}).get('system_name')
for sw in switches.values() for p in (sw.get('ports') or {}).values()}
now = _now_utc()
changed = False
for name in sorted(n for n in names if n):
ups = devices.uplinks_for_host(name, switches)
entry = {'seen': now, 'uplinks': [
{k: u[k] for k in ('switch', 'port', 'port_idx', 'host_interface')} for u in ups]}
if (known.get(name) or {}).get('uplinks') != entry['uplinks']:
changed = True
known[name] = entry
self._known_uplinks = known
# Write when wiring changes, and hourly so "last seen" stays roughly right
last_saved = getattr(self, '_known_uplinks_saved', 0.0)
if changed or time.time() - last_saved > 3600:
db.set_state(KNOWN_UPLINKS_STATE, known)
self._known_uplinks_saved = time.time()
def _load_known_uplinks(self) -> dict:
if getattr(self, '_known_uplinks', None) is None:
self._known_uplinks = {}
raw = db.get_state(KNOWN_UPLINKS_STATE)
if raw:
try:
self._known_uplinks = json.loads(raw)
except ValueError:
logger.error('Failed to parse known_uplinks JSON; starting over')
return self._known_uplinks
def _uplinks_for(self, name: str, switches: dict) -> tuple:
"""(uplinks, None) if the device is linked now, else (last known uplinks, when seen)."""
current = devices.uplinks_for_host(name, switches)
if current:
return current, None
entry = self._load_known_uplinks().get(name) or {}
return entry.get('uplinks') or [], entry.get('seen')
def _where_lines(self, event_type: str, detail: str, host: Optional[str], port: Optional[tuple]) -> list:
base, switches = self._base_url(), self._switches()
lines = []
if host:
ups, seen = self._uplinks_for(host, switches)
if event_type == 'interface_down':
ups = [u for u in ups if u.get('host_interface') == detail] or ups
for u in ups:
live = (switches.get(u['switch'], {}).get('ports') or {}).get(u['port'])
text = ticket_text.port_text(u['switch'], u['port'], live or dict(u, up=False))
iface = f'`{u["host_interface"]}` → ' if u.get('host_interface') else ''
lines.append(f'- {iface}' + ticket_text.link(
text, ticket_text.device_url(base, u['switch'], u.get('port_idx'))))
if seen:
lines[-1] += f' _(last seen linked there {seen})_'
if not ups:
lines.append('- Gandalf has not seen this device on a switch port (no LLDP or client entry).')
if port:
switch, idx = port
live = next((dict(p, name=n) for n, p in (switches.get(switch, {}).get('ports') or {}).items()
if str(p.get('port_idx')) == str(idx)), None)
if live:
lines.append('- ' + ticket_text.link(ticket_text.port_text(switch, live['name'], live),
ticket_text.device_url(base, switch, idx)))
device = host or (port[0] if port else None)
if device:
data = db.cutsheet_load()
items = {i['name']: i for i in data['items']}
runs = cutsheet.runs_for(device, data['cables'], items, switches,
port=str(port[1]) if port else None)
for r in runs:
label = ticket_text.link(f'**{r["label"]}**', ticket_text.cutsheet_url(base, r['cable_id']))
lines.append(f'- Cable {label}: {r["path"]}. Cutsheet check: '
f'{cutsheet.VERDICTS.get(r["verdict"], r["verdict"]).lower()}.')
if not runs:
lines.append('- ' + ticket_text.link('Not on the cutsheet yet', f'{base}/cutsheet' if base else ''))
return lines
def _other_alert_lines(self, event_id: int, names: set) -> list:
lines = []
for name in sorted(n for n in names if n):
for e in db.get_events_for_target(name, limit=25):
if e.get('resolved_at') or e.get('id') == event_id:
continue
what = e['event_type'].replace('_', ' ')
where = f'{e["target_name"]} {e.get("target_detail") or ""}'.strip()
ticket = f' (ticket #{e["ticket_id"]})' if e.get('ticket_id') else ''
lines.append(f'- {what} on {where} since {e.get("first_seen", "?")}{ticket}')
return lines[:10]
def _link_lines(self, device: Optional[str]) -> list:
base = self._base_url()
if not base:
return []
lines = []
if device:
lines.append(f'- {ticket_text.link(f"{device} in Gandalf", ticket_text.device_url(base, device))}')
lines.append(f'- {ticket_text.link(f"Alert history for {device}", ticket_text.history_url(base, device))}')
inventory = db.get_device_link(device)
if inventory:
lines.append(f'- {ticket_text.link(f"{device} in the inventory", inventory)}')
lines.append(f'- {ticket_text.link("Gandalf dashboard", base + "/")}')
return lines
def _event_url(self, event: dict) -> str:
base = self._base_url()
if not base:
return ''
if event['event_type'] == 'cable_mismatch':
cable_id = str(event.get('target_detail') or '').replace('cable ', '')
return ticket_text.cutsheet_url(base, cable_id)
if event['event_type'] in ('cluster_network_issue', 'monitor_source_unavailable'):
return base + '/'
return ticket_text.device_url(base, event['target_name'])
def _post_recovery_notes(self) -> None:
"""Comment on the tickets of alerts that have cleared. Failures retry next cycle (for 24 h)."""
if self.tickets.comments_denied:
return
now = _utcnow()
for event in db.get_pending_recovery_notes(hours=24, exclude_types=ONE_SHOT_EVENTS):
text = ticket_text.recovery_comment(event, now, self._event_url(event))
if self.tickets.comment(event['ticket_id'], text):
db.mark_recovery_notified(event['id'])
elif self.tickets.comments_denied:
break
# ------------------------------------------------------------------
# Interface monitoring (Prometheus)
# ------------------------------------------------------------------
@@ -902,11 +1213,11 @@ class NetworkMonitor:
db.resolve_event('interface_down', host, iface)
else:
if prev is None:
# First observation is down – could be unused port, don't alert
# First observation is down: could be unused port, don't alert
new_baseline[host][iface] = 'initial_down'
elif prev == 'initial_down':
# Persistently down since first observation – no alert
# Persistently down since first observation: no alert
pass
else: # prev == 'up'
@@ -940,12 +1251,12 @@ class NetworkMonitor:
host, instance,
f'No metrics from {host} ({instance}): host or node_exporter is down ({_now_utc()})',
)
if not sup and consec >= self.fail_thresh and not ticket_id:
if not sup and consec >= self.host_fail_thresh and not ticket_id:
self._ticket_metrics_missing(event_id, host, instance, consec)
db.set_baseline(new_baseline)
# Cluster-wide check – only genuine regressions count
# Cluster-wide check: only genuine regressions count
if len(hosts_with_regression) >= self.cluster_thresh:
sup = db.check_suppressed(suppressions, 'all', '')
event_id, is_new, consec, ticket_id = db.upsert_event(
@@ -955,47 +1266,54 @@ class NetworkMonitor:
f'{", ".join(hosts_with_regression)}',
)
if not sup and (is_new or not ticket_id):
title = (
f'[{self.cluster_name}][auto][production][issue][network][cluster-wide] '
f'Multiple hosts reporting interface failures'
)
desc = (
f'Cluster Network Alert\n{"=" * 40}\n\n'
f'Affected hosts: {", ".join(hosts_with_regression)}\n'
f'Detected: {_now_utc()}\n\n'
f'{len(hosts_with_regression)} Proxmox hosts simultaneously reported '
f'interface regressions (link-down on interfaces previously known UP) '
f'or stopped reporting metrics.\n'
f'This likely indicates a switch or upstream network failure.\n\n'
f'Please check the core and management switches immediately.'
)
tid = self.tickets.create(title, desc, priority='1')
if tid:
db.set_ticket_id(event_id, tid)
self._ticket_cluster(event_id, hosts_with_regression)
else:
db.resolve_event('cluster_network_issue', self.cluster_name, '')
def _ticket_cluster(self, event_id: int, hosts: List[str]) -> None:
switches = self._switches()
# The switches these hosts hang off are the likeliest shared cause
shared = sorted({u['switch'] for h in hosts for u in self._uplinks_for(h, switches)[0]})
self._open_ticket(
event_id, 'cluster_network_issue', self.cluster_name, '',
title=(f'[{self.cluster_name}][auto][production][issue][network][cluster-wide] '
f'Multiple hosts reporting interface failures'),
heading='Cluster Network Alert',
facts=[('Affected hosts', ', '.join(hosts)),
('Switches they connect through', ', '.join(shared)),
('Detected', _now_utc())],
summary=(f'{len(hosts)} Proxmox hosts reported interface regressions (link-down on '
f'interfaces previously known up) or stopped reporting metrics at the same time. '
f'This usually means a switch or upstream network failure rather than the hosts.'),
checks=['Check the core and management switches (power, uplinks, recent firmware updates).',
'Check whether the hosts share a PDU or circuit that lost power.',
'Look at the per-host tickets and the Gandalf dashboard for which links went down first.'],
priority='1',
)
def _ticket_metrics_missing(
self, event_id: int, host: str, instance: str, consec: int
) -> None:
title = (
f'[{host}][auto][production][issue][network][single-node] '
f'No metrics from host'
self._open_ticket(
event_id, 'host_metrics_missing', host, instance,
title=f'[{host}][auto][production][issue][network][single-node] No metrics from host',
heading='Host Metrics Alert',
facts=[('Host', host), ('Prometheus instance', instance), ('Detected', _now_utc()),
('Consecutive check failures', str(consec)),
('Down for at least', ticket_text.duration(consec * self._poll_seconds()))],
summary=(f'Prometheus is working but has no node_network_up series for {host}. '
f'Either the host is down or node_exporter has stopped on it. '
f'Gandalf waits {self.host_fail_thresh} checks before opening this, so a normal '
f'reboot should not cause it.'),
checks=[f'Is {host} powered on and reachable (Proxmox UI, ping, console)?',
'If it is up, check `systemctl status prometheus-node-exporter` on the host.',
'If it is down, check its switch port below: a dark port with no PoE or link '
'points to power or cabling.'],
priority='2', host=host,
)
desc = (
f'Host Metrics Alert\n{"=" * 40}\n\n'
f'Host: {host}\n'
f'Prometheus instance: {instance}\n'
f'Detected: {_now_utc()}\n'
f'Consecutive check failures: {consec}\n\n'
f'Prometheus is working but has no node_network_up series for {host}.\n'
f'Either the host is down or node_exporter has stopped on it.\n\n'
f'Please check the host power and network connectivity, then '
f'prometheus-node-exporter on the host.'
)
tid = self.tickets.create(title, desc, priority='2')
if tid:
db.set_ticket_id(event_id, tid)
def _poll_seconds(self) -> int:
return int(getattr(self, 'poll_interval', 120) or 120)
def _process_prometheus_outage(self, suppressions: list) -> None:
"""Interface and host alerts can't fire without Prometheus, so say so."""
@@ -1006,44 +1324,38 @@ class NetworkMonitor:
f'Prometheus returned no interface data; host and interface alerting is paused ({_now_utc()})',
)
if not sup and consec >= self.fail_thresh and not ticket_id:
title = (
'[prometheus][auto][production][issue][network][cluster-wide] '
'Gandalf has no Prometheus data'
self._open_ticket(
event_id, 'monitor_source_unavailable', 'prometheus', '',
title='[prometheus][auto][production][issue][network][cluster-wide] Gandalf has no Prometheus data',
heading='Monitoring Source Alert',
facts=[('Prometheus URL', self.prom.url), ('Detected', _now_utc()),
('Consecutive check failures', str(consec))],
summary=('Gandalf could not get node_network_up data from Prometheus. While this lasts, '
'host and interface failures will **not** be detected. UniFi, ping and modem '
'checks keep running.'),
checks=['Is the Prometheus service running on its host?',
'Open Prometheus → Status → Targets and check the node exporters are being scraped.',
'Check disk space on the Prometheus host (a full disk stops ingestion).'],
priority='2',
)
desc = (
f'Monitoring Source Alert\n{"=" * 40}\n\n'
f'Prometheus URL: {self.prom.url}\n'
f'Detected: {_now_utc()}\n'
f'Consecutive check failures: {consec}\n\n'
f'Gandalf could not get node_network_up data from Prometheus.\n'
f'While this lasts, host and interface failures will NOT be detected.\n\n'
f'Please check the Prometheus service and its scrape targets.'
)
tid = self.tickets.create(title, desc, priority='2')
if tid:
db.set_ticket_id(event_id, tid)
def _ticket_interface(
self, event_id: int, host: str, iface: str, consec: int
) -> None:
title = (
f'[{host}][auto][production][issue][network][single-node] '
f'Interface {iface} link-down'
self._open_ticket(
event_id, 'interface_down', host, iface,
title=f'[{host}][auto][production][issue][network][single-node] Interface {iface} link-down',
heading='Network Interface Alert',
facts=[('Host', host), ('Interface', f'`{iface}`'), ('Detected', _now_utc()),
('Consecutive check failures', str(consec))],
summary=(f'Interface {iface} on {host} was up and is now reporting link-down via '
f'Prometheus node_exporter. {host} itself is still reporting, so it may be '
f'reachable over its other interfaces.'),
checks=['Check the switch port below: is it down on the switch side too?',
'Reseat or swap the cable or DAC; for an optic, check the module for a fault.',
f'On {host}, check `ip link show {iface}` and `dmesg` for NIC or driver errors.'],
priority='2', host=host,
)
desc = (
f'Network Interface Alert\n{"=" * 40}\n\n'
f'Host: {host}\n'
f'Interface: {iface}\n'
f'Detected: {_now_utc()}\n'
f'Consecutive check failures: {consec}\n\n'
f'Interface {iface} on {host} is reporting link-down state via '
f'Prometheus node_exporter.\n\n'
f'Note: {host} may still be reachable via its other network interface.\n'
f'Please inspect the cable/SFP/switch port for {host}/{iface}.'
)
tid = self.tickets.create(title, desc, priority='2')
if tid:
db.set_ticket_id(event_id, tid)
# ------------------------------------------------------------------
# UniFi device monitoring
@@ -1069,23 +1381,68 @@ class NetworkMonitor:
def _ticket_unifi(self, event_id: int, device: dict) -> None:
name = device['name']
title = (
f'[{name}][auto][production][issue][network][single-node] '
f'UniFi device offline'
self._open_ticket(
event_id, 'unifi_device_offline', name, device.get('type', ''),
title=f'[{name}][auto][production][issue][network][single-node] UniFi device offline',
heading='UniFi Device Alert',
facts=[('Device', name), ('Type', device.get('type', 'unknown')), ('Model', device.get('model', '')),
('Last known IP', device.get('ip', 'unknown')), ('Detected', _now_utc())],
summary=(f'The UniFi controller reports {name} as offline. Gandalf waits '
f'{self.unifi_fail_thresh} checks first, so a firmware-update reboot should not cause this.'),
checks=['Check the device for power (status LED) and, if it is PoE powered, the PoE '
'budget on the port below.',
'Check the uplink cable and the switch port it plugs into.',
'In the UniFi controller, check whether the device is stuck adopting or upgrading.'],
priority='2', host=name,
)
desc = (
f'UniFi Device Alert\n{"=" * 40}\n\n'
f'Device: {name}\n'
f'Type: {device.get("type","unknown")}\n'
f'Model: {device.get("model","")}\n'
f'Last Known IP: {device.get("ip","unknown")}\n'
f'Detected: {_now_utc()}\n\n'
f'The UniFi device {name} is offline per the UniFi controller.\n'
f'Please check power and cable connectivity.'
# ------------------------------------------------------------------
# Cutsheet: documented cabling vs. what discovery sees
# ------------------------------------------------------------------
def _process_cutsheet(self, link_data: dict, suppressions: list) -> None:
"""Keep one event per mismatched cable run, and ticket the ones that last.
Events appear on the dashboard and the switch's page straight away; a
ticket waits for cutsheet.mismatch_ticket_hours, so recabling never pages.
"""
data = db.cutsheet_load()
items = {i['name']: i for i in data['items']}
switches = link_data.get('unifi_switches') or {}
found = cutsheet.problems(data['cables'], items, switches)
hours = self.cutsheet_ticket_hours
threshold = max(1, -(-int(hours * 3600) // max(1, self.poll_interval))) if hours else 0
current = set()
for p in found:
current.add((p['switch'], p['key']))
description = f'{p["label"]}: {p["detail"]} (path: {p["path"]})'
event_id, _, consec, ticket_id = db.upsert_event(
'cable_mismatch', 'warning', 'cutsheet', p['switch'], p['key'], description,
)
sup = (db.check_suppressed(suppressions, 'unifi_device', p['switch']) or
db.check_suppressed(suppressions, 'interface', p['switch'], p['port']))
if threshold and not sup and consec >= threshold and not ticket_id:
self._ticket_cable_mismatch(event_id, p, hours)
for target_name, target_detail in db.get_open_event_targets('cable_mismatch'):
if (target_name, target_detail) not in current:
db.resolve_event('cable_mismatch', target_name, target_detail)
def _ticket_cable_mismatch(self, event_id: int, p: dict, hours: float) -> None:
url = ticket_text.cutsheet_url(self._base_url(), p['cable_id'])
self._open_ticket(
event_id, 'cable_mismatch', p['switch'], p['key'],
title=(f'[{p["switch"]}][auto][production][issue][network][single-node] '
f'Cable {p["label"]} does not match the cutsheet'),
heading='Cutsheet Mismatch',
facts=[('Cable', ticket_text.link(p['label'], url)), ('Switch port', f'{p["switch"]} port {p["port"]}'),
('Problem', p['detail']), ('Documented path', p['path']), ('Detected', _now_utc())],
summary=f'This has not matched the cutsheet for at least {hours:g} hours.',
checks=['If the cable was moved on purpose, update its record in the cutsheet.',
'Otherwise, follow the label and check it is plugged into the documented port '
'(Trace mode on the cutsheet page can find which port a cord is in).'],
priority='4', port=(p['switch'], p['port']),
)
tid = self.tickets.create(title, desc, priority='2')
if tid:
db.set_ticket_id(event_id, tid)
# ------------------------------------------------------------------
# Ping-only hosts (no node_exporter)
@@ -1107,7 +1464,7 @@ class NetworkMonitor:
name, ip,
f'Host {name} ({ip}) unreachable via ping ({_now_utc()})',
)
if not sup and consec >= self.fail_thresh and not ticket_id:
if not sup and consec >= self.host_fail_thresh and not ticket_id:
self._ticket_unreachable(event_id, name, ip, consec)
else:
db.resolve_event('host_unreachable', name, ip)
@@ -1115,24 +1472,20 @@ class NetworkMonitor:
def _ticket_unreachable(
self, event_id: int, name: str, ip: str, consec: int
) -> None:
title = (
f'[{name}][auto][production][issue][network][single-node] '
f'Host unreachable'
self._open_ticket(
event_id, 'host_unreachable', name, ip,
title=f'[{name}][auto][production][issue][network][single-node] Host unreachable',
heading='Host Reachability Alert',
facts=[('Host', name), ('IP', ip), ('Detected', _now_utc()),
('Consecutive check failures', str(consec)),
('Down for at least', ticket_text.duration(consec * self._poll_seconds()))],
summary=(f'{name} ({ip}) is not answering ping from the Pulse worker Gandalf uses. '
f'It has no node_exporter, so ping is the only check Gandalf has for it.'),
checks=[f'Is {name} powered on? Check its console or management interface.',
'Check its switch port below for link and PoE.',
'If the port is up, check the IP and firewall on the device itself.'],
priority='2', host=name,
)
desc = (
f'Host Reachability Alert\n{"=" * 40}\n\n'
f'Host: {name}\n'
f'IP: {ip}\n'
f'Detected: {_now_utc()}\n'
f'Consecutive check failures: {consec}\n\n'
f'Host {name} ({ip}) is not responding to ping from the Gandalf monitor.\n'
f'This host does not have a Prometheus node_exporter, so interface-level '
f'detail is unavailable.\n\n'
f'Please check the host power, management interface, and network connectivity.'
)
tid = self.tickets.create(title, desc, priority='2')
if tid:
db.set_ticket_id(event_id, tid)
# ------------------------------------------------------------------
# WAN modem monitoring
@@ -1153,17 +1506,14 @@ class NetworkMonitor:
event_type, severity, 'modem', name, detail, f'{description} ({_now_utc()})',
)
if not sup and consec >= self.modem_fail_thresh and not ticket_id:
title = f'[{name}][auto][production][issue][network][cluster-wide] {heading}'
desc = (
f'WAN Modem Alert\n{"=" * 40}\n\n'
f'Modem: {name} ({self.modem.base_url})\n'
f'Detected: {_now_utc()}\n'
f'Consecutive check failures: {consec}\n\n'
f'{description}\n\n{advice}'
self._open_ticket(
event_id, event_type, name, detail,
title=f'[{name}][auto][production][issue][network][cluster-wide] {heading}',
heading='WAN Modem Alert',
facts=[('Modem', f'{name} ({self.modem.base_url})'), ('Detected', _now_utc()),
('Consecutive check failures', str(consec))],
summary=description, checks=[advice], priority=priority,
)
tid = self.tickets.create(title, desc, priority=priority)
if tid:
db.set_ticket_id(event_id, tid)
def _process_modem_failure(self, suppressions: list, error: Exception) -> None:
"""Handle a failed poll. Link and optical events stay as they are: we can't see them."""
@@ -1305,7 +1655,8 @@ class NetworkMonitor:
if not db.check_suppressed(suppressions, 'host', name) and not ticket_id:
tid = self.tickets.create(
f'[{name}][auto][production][issue][network][cluster-wide] {heading}',
f'WAN Event\n{"=" * 40}\n\nModem: {name}\nReported: {_now_utc()}\n\n{description}\n\n{advice}',
ticket_text.description('WAN Event', [('Modem', name), ('Reported', _now_utc())],
description, [advice], recovers=False),
priority=priority,
)
if tid:
@@ -1473,20 +1824,21 @@ class NetworkMonitor:
# ------------------------------------------------------------------
def run(self) -> None:
logger.info(
f'Gandalf monitor started – poll_interval={self.poll_interval}s '
f'fail_thresh={self.fail_thresh} unifi_fail_thresh={self.unifi_fail_thresh}'
f'Gandalf monitor started: poll_interval={self.poll_interval}s '
f'fail_thresh={self.fail_thresh} host_fail_thresh={self.host_fail_thresh} '
f'unifi_fail_thresh={self.unifi_fail_thresh}'
)
while True:
try:
logger.info('Starting network check cycle')
# 1. Fetch interface states once — shared by snapshot and alert processing
# 1. Fetch interface states once: shared by snapshot and alert processing
iface_states = self.prom.get_interface_states()
# 2. Fetch UniFi devices once — used by both snapshot and alert processing
# 2. Fetch UniFi devices once: used by both snapshot and alert processing
unifi_devices = self.unifi.get_devices()
# 3a. Ping-only hosts once — shared by snapshot and alert processing
# 3a. Ping-only hosts once: shared by snapshot and alert processing
ping_states: Dict[str, Optional[bool]] = {
h['name']: self.pulse.ping(h['ip'])
for h in self.cfg.get('monitor', {}).get('ping_hosts', [])
@@ -1500,11 +1852,18 @@ class NetworkMonitor:
db.set_state('last_check', _now_utc())
# 4. Collect link stats (ethtool + traffic metrics)
link_data = None
try:
link_data = self.link_stats.collect(self._instance_map)
db.set_state('link_stats', link_data)
except Exception as e:
logger.error(f'Link stats collection failed: {e}', exc_info=True)
if link_data is not None:
self._link_data = link_data
try:
self._remember_uplinks(link_data)
except Exception as e:
logger.error(f'Recording known uplinks failed: {e}', exc_info=True)
# 5. Process alerts using already-fetched data
suppressions = db.get_active_suppressions()
@@ -1517,6 +1876,13 @@ class NetworkMonitor:
self._process_ping_hosts(suppressions, ping_states)
# Cutsheet: compare documented cabling with what was just discovered
if link_data is not None:
try:
self._process_cutsheet(link_data, suppressions)
except Exception as e:
logger.error(f'Cutsheet check failed: {e}', exc_info=True)
# WAN modem: isolated so a failure here can't stop the rest of the cycle
if self.modem:
try:
@@ -1526,6 +1892,12 @@ class NetworkMonitor:
except Exception as e:
logger.error(f'Modem collection failed: {e}', exc_info=True)
# Note on the tickets of anything that cleared this cycle (or failed to post before)
try:
self._post_recovery_notes()
except Exception as e:
logger.error(f'Posting recovery notes failed: {e}', exc_info=True)
# Housekeeping: deactivate expired suppressions and purge old resolved events
db.cleanup_expired_suppressions()
db.purge_old_resolved_events(days=90)
+65 -2
View File
@@ -1,4 +1,4 @@
-- Gandalf Network Monitor – Database Schema
-- Gandalf Network Monitor: Database Schema
-- Run on MariaDB LXC 149 (10.10.10.50)
CREATE DATABASE IF NOT EXISTS gandalf
@@ -21,8 +21,9 @@ CREATE TABLE IF NOT EXISTS network_events (
resolved_at TIMESTAMP NULL,
consecutive_failures INT NOT NULL DEFAULT 1,
ticket_id VARCHAR(20) NULL,
recovery_notified TINYINT(1) NOT NULL DEFAULT 0, -- recovery comment posted on ticket_id
INDEX idx_active (resolved_at),
INDEX idx_active (resolved_at),
INDEX idx_target (target_name, target_detail),
INDEX idx_type (event_type),
-- Compound index for hot upsert_event lookup: event_type+target+resolved_at
@@ -61,3 +62,65 @@ CREATE TABLE IF NOT EXISTS monitor_state (
value MEDIUMTEXT NOT NULL,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB;
-- ── Cutsheets (planned cabling) ────────────────────────────────────────
-- Also created automatically on first use (db.ensure_cutsheet_schema).
CREATE TABLE IF NOT EXISTS cutsheet_items ( -- panels, jacks, shelves, rack positions
id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(100) NOT NULL,
kind VARCHAR(20) NOT NULL, -- patch_panel, wall_jack, device, shelf, other
port_count SMALLINT NULL,
location VARCHAR(255) NOT NULL DEFAULT '',
rack_u SMALLINT NULL, -- bottom rack unit
rack_height SMALLINT NULL,
notes TEXT NULL,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
UNIQUE KEY uq_item_name (name)
) ENGINE=InnoDB;
CREATE TABLE IF NOT EXISTS cutsheet_cables ( -- one row per physical cable
id INT AUTO_INCREMENT PRIMARY KEY,
label VARCHAR(32) NULL, -- the ID on the cable, e.g. C07
a_device VARCHAR(100) NOT NULL, -- device or item name
a_port VARCHAR(64) NOT NULL DEFAULT '', -- switch port number, interface, or panel port
a_side VARCHAR(5) NOT NULL DEFAULT '', -- front/rear, for panels and jacks
b_device VARCHAR(100) NOT NULL DEFAULT '', -- blank = unterminated
b_port VARCHAR(64) NOT NULL DEFAULT '',
b_side VARCHAR(5) NOT NULL DEFAULT '',
cable_type VARCHAR(32) NOT NULL DEFAULT '',
length_m DECIMAL(5,2) NULL,
color VARCHAR(32) NOT NULL DEFAULT '',
status VARCHAR(10) NOT NULL DEFAULT 'installed', -- planned, installed, dark, retired
label_applied BOOLEAN NOT NULL DEFAULT FALSE,
notes TEXT NULL,
created_by VARCHAR(255) NOT NULL DEFAULT '',
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_by VARCHAR(255) NOT NULL DEFAULT '',
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
UNIQUE KEY uq_cable_label (label),
INDEX idx_cable_a (a_device, a_port),
INDEX idx_cable_b (b_device, b_port)
) ENGINE=InnoDB;
CREATE TABLE IF NOT EXISTS cutsheet_port_labels ( -- e.g. the room name on a panel port
item_id INT NOT NULL,
port VARCHAR(64) NOT NULL,
label VARCHAR(64) NOT NULL DEFAULT '',
applied BOOLEAN NOT NULL DEFAULT FALSE,
PRIMARY KEY (item_id, port)
) ENGINE=InnoDB;
CREATE TABLE IF NOT EXISTS cutsheet_history ( -- who changed what, and when
id INT AUTO_INCREMENT PRIMARY KEY,
changed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
changed_by VARCHAR(255) NOT NULL,
entity VARCHAR(12) NOT NULL, -- cable, item, port_label
entity_id INT NOT NULL,
action VARCHAR(10) NOT NULL, -- create, update, delete
summary VARCHAR(500) NOT NULL,
before_json TEXT NULL,
after_json TEXT NULL,
INDEX idx_hist_time (changed_at),
INDEX idx_hist_entity (entity, entity_id)
) ENGINE=InnoDB;
+15 -15
View File
@@ -11,13 +11,13 @@
const resp = await _fetch(...args);
if (resp.status === 401) {
window.location.reload();
throw new Error('Session expired — reloading');
throw new Error('Session expired, reloading');
}
return resp;
};
})();
// ── Toast notifications — thin wrapper over lt.toast ──────────────────
// ── Toast notifications: thin wrapper over lt.toast ──────────────────
function showToast(msg, type = 'success') {
if (type === 'error') return lt.toast.error(msg);
if (type === 'warning') return lt.toast.warning(msg);
@@ -116,7 +116,7 @@ function updateStatusBar(summary, lastCheck, daemonOk) {
}
const mins = Math.floor(checkAge / 60);
staleBanner.querySelector('.lt-alert-msg').textContent =
`Monitoring data is stale — last check was ${mins} minute${mins !== 1 ? 's' : ''} ago. The monitor daemon may be down.`;
`Monitoring data is stale: last check was ${mins} minute${mins !== 1 ? 's' : ''} ago. The monitor daemon may be down.`;
staleBanner.style.display = '';
} else if (staleBanner) {
staleBanner.style.display = 'none';
@@ -233,7 +233,7 @@ function initDeviceSearch() {
}
results.innerHTML = matches.map((d, i) => `
<a class="device-search-row${i === active ? ' is-active' : ''}" id="device-opt-${i}" role="option"
aria-selected="${i === active}" href="${lt.escHtml(deviceUrl(d.name))}">
aria-selected="${i === active}" href="${lt.escHtml(d.url || deviceUrl(d.name))}">
<span class="dot-${lt.escHtml(d.status)}"></span>
<span class="device-search-name">${lt.escHtml(d.name)}</span>
<span class="device-search-kind">${lt.escHtml(d.kind)}</span>
@@ -250,7 +250,7 @@ function initDeviceSearch() {
if (!matches.length) return;
if (e.key === 'ArrowDown') { e.preventDefault(); active = (active + 1) % matches.length; render(); }
if (e.key === 'ArrowUp') { e.preventDefault(); active = (active - 1 + matches.length) % matches.length; render(); }
if (e.key === 'Enter') { e.preventDefault(); window.location.href = deviceUrl(matches[active].name); }
if (e.key === 'Enter') { e.preventDefault(); window.location.href = matches[active].url || deviceUrl(matches[active].name); }
});
document.addEventListener('click', e => {
if (!e.target.closest('#device-search')) close();
@@ -275,7 +275,7 @@ async function refreshModem() {
}
function _modemUptime(seconds) {
if (seconds === null || seconds === undefined) return '–';
if (seconds === null || seconds === undefined) return '-';
const d = Math.floor(seconds / 86400);
const h = Math.floor((seconds % 86400) / 3600);
const m = Math.floor((seconds % 3600) / 60);
@@ -283,7 +283,7 @@ function _modemUptime(seconds) {
}
function _modemRate(bytesPerSec) {
if (bytesPerSec === null || bytesPerSec === undefined) return '–';
if (bytesPerSec === null || bytesPerSec === undefined) return '-';
const mbps = bytesPerSec * 8 / 1e6;
return mbps >= 1000 ? `${(mbps / 1000).toFixed(2)} Gbps` : `${mbps.toFixed(1)} Mbps`;
}
@@ -298,7 +298,7 @@ function _modemStat(label, value, cls, note) {
}
function _modemOptic(label, metric, status, unit) {
if (!metric || metric.value === null || metric.value === undefined) return _modemStat(label, '–');
if (!metric || metric.value === null || metric.value === undefined) return _modemStat(label, '-');
const cls = { alarm: 'lt-text-red', warning: 'lt-text-amber', ok: 'lt-text-green' }[status] || '';
return _modemStat(label, `${metric.value} ${unit}`, cls, `warn ${metric.warn_low} to ${metric.warn_high}`);
}
@@ -391,7 +391,7 @@ function updateModem(data) {
if (topo) topo.classList.add('topo-v2-status-down');
body.innerHTML = `
<div class="modem-error">Modem status unavailable: ${lt.escHtml(data.error || 'unknown error')}
<span class="modem-stat-note">Last attempt ${lt.escHtml(data.updated || '–')}</span></div>
<span class="modem-stat-note">Last attempt ${lt.escHtml(data.updated || '-')}</span></div>
${_modemChart(data.history)}`;
return;
}
@@ -404,7 +404,7 @@ function updateModem(data) {
const rx = optics.rx_power ? optics.rx_power.value : null;
if (topo) topo.classList.toggle('topo-v2-status-down', problems.length > 0);
if (rxLabel) rxLabel.textContent = (rx === null || rx === undefined) ? 'Rx –' : `Rx ${rx} dBm`;
if (rxLabel) rxLabel.textContent = (rx === null || rx === undefined) ? 'Rx -' : `Rx ${rx} dBm`;
if (title) {
title.textContent = [data.model || 'AT&T Gateway', data.firmware && `fw ${data.firmware}`]
.filter(Boolean).join(' · ');
@@ -417,7 +417,7 @@ function updateModem(data) {
<div class="modem-stats">
${_modemStat('WAN', problems.length ? 'DOWN' : 'UP', problems.length ? 'lt-text-red' : 'lt-text-green',
data.wan_ip || '')}
${_modemStat('PON', data.pon_state || '–', '', data.wavelength || '')}
${_modemStat('PON', data.pon_state || '-', '', data.wavelength || '')}
${_modemOptic('Rx power', optics.rx_power, status.rx_power, 'dBm')}
${_modemOptic('Tx power', optics.tx_power, status.tx_power, 'dBm')}
${_modemOptic('Optics temp', optics.temperature, status.temperature, '°C')}
@@ -427,7 +427,7 @@ function updateModem(data) {
</div>
${_modemChart(data.history)}
${_modemOutages(data.wan_history)}
<div class="modem-stat-note modem-updated">Updated ${lt.escHtml(data.updated || '–')}</div>`;
<div class="modem-stat-note modem-updated">Updated ${lt.escHtml(data.updated || '-')}</div>`;
}
function updateUnifiTable(devices) {
@@ -481,7 +481,7 @@ function updateEventsTable(events, totalActive) {
const ticket = e.ticket_id
? `<a href="${lt.escHtml(ticketBase)}${lt.escHtml(String(e.ticket_id))}" target="_blank"
class="ticket-link">#${lt.escHtml(String(e.ticket_id))}</a>`
: '–';
: '-';
const supBadge = e.is_suppressed
? `<span class="lt-badge badge-suppressed" title="Alert suppressed">🔕 sup</span>`
: '';
@@ -490,7 +490,7 @@ function updateEventsTable(events, totalActive) {
<td><span class="lt-badge badge-${e.severity}">${e.severity}</span>${supBadge}</td>
<td>${lt.escHtml(e.event_type.replace(/_/g,' '))}</td>
<td><strong>${lt.escHtml(e.target_name)}</strong></td>
<td>${lt.escHtml(e.target_detail || '–')}</td>
<td>${lt.escHtml(e.target_detail || '-')}</td>
<td class="desc-cell" title="${lt.escHtml(e.description || '')}">${lt.escHtml((e.description||'').substring(0,60))}${(e.description||'').length>60?'…':''}</td>
<td class="ts-cell" title="${lt.escHtml(e.first_seen||'')}">${lt.time.ago(_toIso(e.first_seen))}</td>
<td class="ts-cell" title="${lt.escHtml(e.last_seen||'')}">${lt.time.ago(_toIso(e.last_seen))}</td>
@@ -618,7 +618,7 @@ async function submitSuppress(e) {
}
}
// ── Suppress form – wired here so the modal works from any page ──────
// ── Suppress form: wired here so the modal works from any page ──────
document.getElementById('suppress-form')?.addEventListener('submit', submitSuppress);
document.getElementById('sup-type')?.addEventListener('change', updateSuppressForm);
+8 -8
View File
@@ -347,7 +347,7 @@
'[ OK ] Scheduled tasks registered',
'[ OK ] Terminal interface rendered',
'',
'> ALL SYSTEMS NOMINAL — ' + name,
'> ALL SYSTEMS NOMINAL: ' + name,
'',
];
@@ -486,7 +486,7 @@
---------------------------------------------------------------- */
function timeAgo(value) {
const date = value instanceof Date ? value : new Date(value);
if (isNaN(date)) return '—';
if (isNaN(date)) return '-';
const diff = Math.floor((Date.now() - date.getTime()) / 1000);
if (diff < 60) return diff + 's ago';
if (diff < 3600) return Math.floor(diff / 60) + 'm ago';
@@ -505,7 +505,7 @@
function formatDate(value) {
const date = value instanceof Date ? value : new Date(value);
if (isNaN(date)) return '—';
if (isNaN(date)) return '-';
try {
return date.toLocaleString(undefined, {
timeZone: global.APP_TIMEZONE || undefined,
@@ -522,7 +522,7 @@
lt.bytes.format(n)
---------------------------------------------------------------- */
function formatBytes(bytes) {
if (bytes == null) return '—';
if (bytes == null) return '-';
const units = ['B','KB','MB','GB','TB']; let i = 0;
while (bytes >= 1024 && i < units.length - 1) { bytes /= 1024; i++; }
return bytes.toFixed(i === 0 ? 0 : 2) + ' ' + units[i];
@@ -1137,9 +1137,9 @@
lt.num.format / compact / percent / pad / clamp / lerp
---------------------------------------------------------------- */
const num = {
format(n, d) { if (n == null || isNaN(n)) return '—'; return Number(n).toLocaleString(undefined, { minimumFractionDigits: d || 0, maximumFractionDigits: d != null ? d : 2 }); },
format(n, d) { if (n == null || isNaN(n)) return '-'; return Number(n).toLocaleString(undefined, { minimumFractionDigits: d || 0, maximumFractionDigits: d != null ? d : 2 }); },
compact(n) { if (Math.abs(n) >= 1e9) return (n/1e9).toFixed(1)+'B'; if (Math.abs(n) >= 1e6) return (n/1e6).toFixed(1)+'M'; if (Math.abs(n) >= 1e3) return (n/1e3).toFixed(1)+'K'; return String(n); },
percent(n, total) { return total ? ((n/total)*100).toFixed(1)+'%' : '—'; },
percent(n, total) { return total ? ((n/total)*100).toFixed(1)+'%' : '-'; },
pad(n, w) { return String(Math.floor(n)).padStart(w, '0'); },
clamp(n, a, b) { return Math.min(b, Math.max(a, n)); },
lerp(a, b, t) { return a + (b - a) * t; },
@@ -1759,7 +1759,7 @@
_offlineBanner.className = 'lt-offline-banner';
_offlineBanner.setAttribute('role', 'alert');
_offlineBanner.setAttribute('aria-live', 'assertive');
_offlineBanner.innerHTML = '<span class="lt-dot lt-dot--red"></span> NO NETWORK CONNECTION — RECONNECTING...';
_offlineBanner.innerHTML = '<span class="lt-dot lt-dot--red"></span> NO NETWORK CONNECTION, RECONNECTING...';
document.body.appendChild(_offlineBanner);
}
}
@@ -1770,7 +1770,7 @@
window.addEventListener('offline', () => {
document.body.classList.add('lt-is-offline');
_offlineGetBanner().classList.add('is-visible');
toast.warning('Connection lost — working offline');
toast.warning('Connection lost, working offline');
_offlineHandlers.forEach(fn => fn());
});
window.addEventListener('online', () => {
+722
View File
@@ -0,0 +1,722 @@
'use strict';
/* global CS_CAN_EDIT, deviceUrl */
// Cutsheet page: renders /api/cutsheet and edits cables, items and panel-port labels.
const esc = s => lt.escHtml(s == null ? '' : String(s));
const VERDICT_CLASS = {
match: 'badge-ok', wrong_neighbor: 'badge-critical', no_link: 'badge-critical', missing_port: 'badge-critical',
conflict: 'badge-critical', unverified: 'badge-info', idle: 'badge-neutral', not_checked: 'badge-neutral',
planned: 'badge-purple', dark: 'badge-neutral', retired: 'badge-neutral',
};
const VERDICT_SHORT = {
match: 'Matches', wrong_neighbor: 'Wrong neighbor', no_link: 'No link', missing_port: 'Missing port',
conflict: 'Port conflict', unverified: 'Unverified', idle: 'Idle', not_checked: 'Not checked',
planned: 'Planned', dark: 'Dark', retired: 'Retired',
};
const KIND_TEXT = { patch_panel: 'Patch panel', wall_jack: 'Wall jack', device: 'Device', shelf: 'Shelf', other: 'Other' };
let _cs = null;
let _showAllSuggestions = false;
const SUGGESTIONS_SHOWN = 10;
function natural(a, b) {
return String(a).localeCompare(String(b), undefined, { numeric: true, sensitivity: 'base' });
}
function itemByName(name) {
return (_cs.items || []).find(i => i.name === name);
}
function isPassive(name) {
const item = itemByName(name);
return !!(item && _cs.options.passive_kinds.includes(item.kind));
}
function verdictBadge(c) {
return `<span class="lt-badge ${VERDICT_CLASS[c.verdict] || 'badge-neutral'}" title="${esc(c.detail)}">${esc(VERDICT_SHORT[c.verdict] || c.verdict)}</span>`;
}
function deviceLink(name) {
if (!name) return '<span class="val-neutral">unterminated</span>';
const item = itemByName(name);
const known = (_cs.catalog || []).some(d => d.name === name && (d.kind === 'switch' || d.kind === 'host'));
if (item && !known) return `<a class="device-link" href="#item-${esc(item.id)}">${esc(name)}</a>`;
return `<a class="device-link" href="${esc(deviceUrl(name))}">${esc(name)}</a>`;
}
function endText(c, end) {
const device = c[`${end}_device`];
if (!device) return deviceLink('');
const port = c[`${end}_port`];
const side = c[`${end}_side`];
let text = deviceLink(device);
if (port) text += ` <span class="cs-port">${/^\d+$/.test(port) ? 'port ' : ''}${esc(port)}</span>`;
if (side) text += ` <span class="cs-side-tag">${esc(side)}</span>`;
return text;
}
function pathText(c) {
// The run beyond this cable, through any panels or jacks
const nodes = (c.path || []).filter(h => !('cable_id' in h)).map(h => h.text);
return nodes.length > 2 ? nodes.map(esc).join(' → ') : '';
}
// ── Rendering ───────────────────────────────────────────────────────────
function renderSummary() {
const cables = _cs.cables.filter(c => c.status !== 'retired');
const problems = cables.filter(c => c.problem).length;
const matches = cables.filter(c => c.verdict === 'match').length;
const labels = _cs.labels.cables.length + _cs.labels.ports.length;
const chip = (n, text, cls, target) =>
`<a class="cs-chip ${cls}" href="#${target}"><b>${n}</b> ${esc(text)}</a>`;
document.getElementById('cs-summary').innerHTML = [
chip(cables.length, 'cables', '', 'cs-cables-section'),
chip(matches, 'match what Gandalf sees', 'cs-chip-ok', 'cs-cables-section'),
chip(problems, problems === 1 ? 'problem' : 'problems', problems ? 'cs-chip-bad' : '', 'cs-cables-section'),
chip(_cs.suggestions.length, 'undocumented links', _cs.suggestions.length ? 'cs-chip-warn' : '', 'cs-suggest-section'),
chip(labels, 'labels to make', labels ? 'cs-chip-warn' : '', 'cs-labels-section'),
].join('');
}
function cableMatches(c, words, status, problemsOnly) {
if (status && c.status !== status) return false;
if (problemsOnly && !c.problem) return false;
if (!words.length) return true;
const hay = [c.label, c.a_text, c.b_text, c.cable_type, c.color, c.notes, c.detail, c.status]
.join(' ').toLowerCase();
return words.every(w => hay.includes(w));
}
function renderCables() {
const words = document.getElementById('cs-filter').value.trim().toLowerCase().split(/\s+/).filter(Boolean);
const status = document.getElementById('cs-status-filter').value;
const problemsOnly = document.getElementById('cs-problems-only').checked;
const rows = _cs.cables
.filter(c => cableMatches(c, words, status, problemsOnly))
.sort((a, b) => (b.problem - a.problem) || natural(a.label || '~', b.label || '~') || a.id - b.id);
document.getElementById('cs-cable-count').textContent = _cs.cables.length;
const wrap = document.getElementById('cs-cables');
if (!_cs.cables.length) {
wrap.innerHTML = emptyState('🔌', 'No cables yet',
CS_CAN_EDIT ? 'Add one with + Cable, or start from the undocumented links below.' : 'An admin can add cables.');
return;
}
if (!rows.length) {
wrap.innerHTML = emptyState('🔍', 'No cables match the filter', '');
return;
}
wrap.innerHTML = `
<div class="lt-table-wrap">
<table class="lt-table cs-table">
<caption class="lt-sr-only">Cables</caption>
<thead><tr><th>ID</th><th>From</th><th>To</th><th>Type</th><th>Status</th><th>Check</th>${CS_CAN_EDIT ? '<th class="no-print"></th>' : ''}</tr></thead>
<tbody>${rows.map(c => `
<tr id="cable-${esc(c.id)}" class="${c.problem ? 'cs-row-problem' : ''}${c.status === 'retired' ? ' row-resolved' : ''}">
<td class="cs-id">${c.label ? esc(c.label) : '<span class="val-neutral">-</span>'}${c.label && !c.label_applied && c.status !== 'retired' ? ' <span class="cs-tag" title="The label isn\'t on the cable yet">not stuck on</span>' : ''}</td>
<td data-label="From">${endText(c, 'a')}</td>
<td data-label="To">${endText(c, 'b')}${pathText(c) ? `<div class="cs-path">${pathText(c)}</div>` : ''}</td>
<td data-label="Type">${esc([c.cable_type, c.length_m ? `${c.length_m} m` : '', c.color].filter(Boolean).join(' · ')) || '-'}</td>
<td data-label="Status">${esc(c.status)}</td>
<td data-label="Check">${verdictBadge(c)}<div class="cs-detail">${esc(c.detail)}</div></td>
${CS_CAN_EDIT ? `<td class="no-print"><button type="button" class="lt-btn lt-btn-secondary lt-btn-sm" data-action="edit-cable" data-id="${esc(c.id)}" aria-label="Edit cable ${esc(c.label || c.id)}">Edit</button></td>` : ''}
</tr>`).join('')}
</tbody>
</table>
</div>`;
}
function renderSuggestions() {
const list = _cs.suggestions;
document.getElementById('cs-suggest-count').textContent = list.length;
const wrap = document.getElementById('cs-suggestions');
if (!list.length) {
wrap.innerHTML = emptyState('✅', 'Every live switch port is documented', '');
return;
}
wrap.innerHTML = `
<div class="lt-table-wrap">
<table class="lt-table lt-table-sm">
<caption class="lt-sr-only">Undocumented links</caption>
<thead><tr><th>Switch port</th><th>UniFi name</th><th>Sees</th><th>Found by</th>${CS_CAN_EDIT ? '<th></th>' : ''}</tr></thead>
<tbody>${list.slice(0, _showAllSuggestions ? list.length : SUGGESTIONS_SHOWN).map((s, i) => `
<tr>
<td>${deviceLink(s.switch)} <span class="cs-port">port ${esc(s.port_idx)}</span></td>
<td>${esc(s.port_name)}</td>
<td>${s.neighbor ? `${deviceLink(s.neighbor)}${s.neighbor_port ? ` <span class="cs-port">${esc(s.neighbor_port)}</span>` : ''}` : '<span class="val-neutral">unknown</span>'}</td>
<td>${esc(s.via || 'link only')}</td>
${CS_CAN_EDIT ? `<td><button type="button" class="lt-btn lt-btn-secondary lt-btn-sm" data-action="add-suggestion" data-i="${i}">Add</button></td>` : ''}
</tr>`).join('')}
</tbody>
</table>
</div>
${list.length > SUGGESTIONS_SHOWN ? `<button type="button" class="lt-btn lt-btn-secondary lt-btn-sm cs-more" data-action="toggle-suggestions">
${_showAllSuggestions ? 'Show fewer' : `Show all ${list.length}`}</button>` : ''}`;
}
function cableAt(name, port, side) {
return _cs.cables.find(c => c.status !== 'retired' &&
['a', 'b'].some(e => c[`${e}_device`] === name && c[`${e}_port`] === String(port) && c[`${e}_side`] === side));
}
function farEnd(c, name, port, side) {
const end = (c.a_device === name && c.a_port === String(port) && c.a_side === side) ? 'b' : 'a';
return endText(c, end);
}
function renderPanels() {
const panels = _cs.items.filter(i => i.kind === 'patch_panel').sort((a, b) => natural(a.name, b.name));
const wrap = document.getElementById('cs-panels');
if (!panels.length) {
wrap.innerHTML = emptyState('🗄️', 'No patch panels yet', CS_CAN_EDIT ? 'Add one with + Panel / item.' : '');
return;
}
const labels = {};
for (const l of _cs.port_labels) labels[`${l.item_id}|${l.port}`] = l;
wrap.innerHTML = panels.map(p => {
const rows = [];
for (let n = 1; n <= (p.port_count || 0); n++) {
const front = cableAt(p.name, n, 'front');
const rear = cableAt(p.name, n, 'rear');
const lab = labels[`${p.id}|${n}`];
const cell = (c, side) => c
? `<a class="cs-id" href="#cable-${esc(c.id)}">${esc(c.label || 'unlabeled')}</a> → ${farEnd(c, p.name, n, side)}`
: '<span class="val-neutral">-</span>';
rows.push(`
<tr>
<td class="cs-id">${n}</td>
<td>${lab ? esc(lab.label) + (lab.applied ? '' : ' <span class="cs-tag">not stuck on</span>') : '<span class="val-neutral">-</span>'}
${CS_CAN_EDIT ? `<button type="button" class="cs-link-btn no-print" data-action="edit-port-label" data-item="${esc(p.id)}" data-port="${n}" aria-label="Edit label for ${esc(p.name)} port ${n}">edit</button>` : ''}</td>
<td>${cell(front, 'front')}</td>
<td>${cell(rear, 'rear')}</td>
</tr>`);
}
return `
<div class="lt-frame cs-panel" id="item-${esc(p.id)}">
<span class="lt-frame-bl">&#x255A;</span><span class="lt-frame-br">&#x255D;</span>
<div class="lt-section-header">${esc(p.name)}${p.rack_u ? ` · U${esc(p.rack_u)}` : ''}${p.location ? ` · ${esc(p.location)}` : ''}</div>
<div class="lt-table-wrap">
<table class="lt-table lt-table-sm">
<caption class="lt-sr-only">Ports on ${esc(p.name)}</caption>
<thead><tr><th>Port</th><th>Label</th><th>Front (patch cord)</th><th>Rear (run)</th></tr></thead>
<tbody>${rows.join('')}</tbody>
</table>
</div>
</div>`;
}).join('');
}
function renderLabels() {
const { cables, ports, unlabeled_cable_ids: unlabeled } = _cs.labels;
document.getElementById('cs-label-count').textContent = cables.length + ports.length;
const wrap = document.getElementById('cs-labels');
if (!cables.length && !ports.length) {
wrap.innerHTML = emptyState('🏷️', 'Nothing to label', unlabeled.length
? `${unlabeled.length} cable(s) have no ID yet: give them one to add them here.` : '');
return;
}
const tick = (attrs, label) => CS_CAN_EDIT
? `<input type="checkbox" class="no-print" ${attrs} aria-label="${esc(label)}">` : '';
wrap.innerHTML = `
<div class="cs-label-grid">
${cables.map(c => `
<div class="cs-label-card">
${tick(`data-action="applied-cable" data-id="${esc(c.id)}"`, `${c.text} is stuck on`)}
<span class="cs-label-text">${esc(c.text)}</span>
<span class="cs-label-copies">×${esc(c.copies)}</span>
<span class="cs-label-where">${esc(c.where)}</span>
</div>`).join('')}
${ports.map(p => `
<div class="cs-label-card">
${tick(`data-action="applied-port" data-item="${esc(p.item)}" data-port="${esc(p.port)}"`, `${p.text} is stuck on`)}
<span class="cs-label-text">${esc(p.text)}</span>
<span class="cs-label-copies">×1</span>
<span class="cs-label-where">${esc(p.item)} port ${esc(p.port)}</span>
</div>`).join('')}
</div>
${unlabeled.length ? `<p class="cs-hint">${unlabeled.length} more cable(s) have no ID yet.</p>` : ''}`;
}
function renderRack() {
const placed = _cs.items.filter(i => i.rack_u).sort((a, b) => (b.rack_u + (b.rack_height || 1)) - (a.rack_u + (a.rack_height || 1)));
const wrap = document.getElementById('cs-rack');
if (!placed.length) {
wrap.innerHTML = emptyState('🗄️', 'No rack positions recorded', CS_CAN_EDIT ? 'Set a rack unit on a panel, shelf or device in the inventory.' : '');
return;
}
wrap.innerHTML = `
<div class="cs-rack">
${placed.map(i => {
const top = i.rack_u + (i.rack_height || 1) - 1;
return `
<div class="cs-rack-unit" style="--u:${Math.min(i.rack_height || 1, 8)}">
<span class="cs-rack-u">${i.rack_height > 1 ? `U${esc(top)}-${esc(i.rack_u)}` : `U${esc(i.rack_u)}`}</span>
<span class="cs-rack-name">${deviceLink(i.name)}</span>
<span class="cs-rack-kind">${esc(KIND_TEXT[i.kind] || i.kind)}</span>
</div>`;
}).join('')}
</div>`;
}
function rackText(i) {
if (i.shelf) return `on ${esc(i.shelf)}`;
if (!i.rack_u) return '-';
const side = { rear: ' rear', full: ' full depth' }[i.mount] || '';
const where = `U${esc(i.rack_u)}${i.rack_height > 1 ? ` (${esc(i.rack_height)}U)` : ''}${side}`;
return (_cs.racks || []).length > 1 ? `${where} · ${esc(i.rack || _cs.racks[0])}` : where;
}
function renderItems() {
const items = [..._cs.items].sort((a, b) => natural(a.kind, b.kind) || natural(a.name, b.name));
document.getElementById('cs-item-count').textContent = items.length;
const wrap = document.getElementById('cs-items');
if (!items.length) {
wrap.innerHTML = emptyState('📦', 'No items yet', CS_CAN_EDIT ? 'Add your patch panel first: + Panel / item.' : '');
return;
}
wrap.innerHTML = `
<div class="lt-table-wrap">
<table class="lt-table lt-table-sm">
<caption class="lt-sr-only">Inventory</caption>
<thead><tr><th>Name</th><th>Kind</th><th>Ports</th><th>Rack</th><th>Location</th><th>Notes</th>${CS_CAN_EDIT ? '<th class="no-print"></th>' : ''}</tr></thead>
<tbody>${items.map(i => `
<tr id="${i.kind === 'patch_panel' ? '' : `item-${esc(i.id)}`}">
<td>${deviceLink(i.name)}</td>
<td>${esc(KIND_TEXT[i.kind] || i.kind)}</td>
<td>${esc(i.port_count || '-')}</td>
<td>${rackText(i)}</td>
<td>${esc(i.location || '-')}</td>
<td>${esc(i.notes || '')}</td>
${CS_CAN_EDIT ? `<td class="no-print"><button type="button" class="lt-btn lt-btn-secondary lt-btn-sm" data-action="edit-item" data-id="${esc(i.id)}" aria-label="Edit ${esc(i.name)}">Edit</button></td>` : ''}
</tr>`).join('')}
</tbody>
</table>
</div>`;
}
function renderHistory() {
const rows = _cs.history || [];
const wrap = document.getElementById('cs-history');
if (!rows.length) {
wrap.innerHTML = emptyState('📋', 'No changes yet', '');
return;
}
wrap.innerHTML = `
<div class="lt-table-wrap">
<table class="lt-table lt-table-sm">
<caption class="lt-sr-only">Change history</caption>
<thead><tr><th>When</th><th>Who</th><th>Change</th></tr></thead>
<tbody>${rows.map(h => `
<tr><td class="ts-cell">${esc(fmtWhen(h.changed_at))}</td><td>${esc(h.changed_by)}</td><td>${esc(h.summary)}</td></tr>`).join('')}
</tbody>
</table>
</div>`;
}
function fmtWhen(iso) {
const d = new Date(iso);
return isNaN(d) ? iso : d.toLocaleString();
}
function emptyState(icon, title, body) {
return `<div class="lt-empty-state lt-empty-state--sm"><div class="lt-empty-state-icon">${icon}</div>
<div class="lt-empty-state-title">${esc(title)}</div>${body ? `<div class="lt-empty-state-body">${esc(body)}</div>` : ''}</div>`;
}
function renderDatalists() {
document.getElementById('cs-device-list').innerHTML =
(_cs.catalog || []).map(d => `<option value="${esc(d.name)}">${esc(d.kind)}</option>`).join('');
}
function render() {
renderSummary();
renderCables();
renderSuggestions();
renderPanels();
renderLabels();
renderRack();
renderItems();
renderHistory();
renderDatalists();
renderTracePanels();
}
async function load() {
try {
_cs = await lt.api.get('/api/cutsheet');
} catch (err) {
document.getElementById('cs-summary').innerHTML =
`<div class="lt-badge badge-critical">Couldn't load the cutsheet: ${esc(err.message)}</div>`;
return;
}
render();
const hash = window.location.hash;
if (hash && /^#(cable|item)-\d+$/.test(hash)) {
const el = document.getElementById(hash.slice(1));
if (el) { el.classList.add('cs-flash'); el.scrollIntoView({ block: 'center' }); }
}
}
// ── Editing ─────────────────────────────────────────────────────────────
function fillPorts(end) {
const device = document.querySelector(`#cs-cable-form [name="${end}_device"]`).value;
const entry = (_cs.catalog || []).find(d => d.name === device);
document.getElementById(`cs-${end}-port-list`).innerHTML = entry
? entry.ports.map(p => `<option value="${esc(p.value)}">${esc(p.text)}</option>`).join('') : '';
const side = document.querySelector(`.cs-side[data-end="${end}"]`);
side.hidden = !isPassive(device);
}
function openCable(cable, prefill) {
const form = document.getElementById('cs-cable-form');
form.reset();
const types = ['', ..._cs.options.cable_types];
form.cable_type.innerHTML = types.map(t => `<option value="${esc(t)}">${esc(t || '-')}</option>`).join('');
const data = Object.assign({ status: 'installed', label: cable ? '' : _cs.next_label }, cable || {}, prefill || {});
for (const key of ['id', 'label', 'a_device', 'a_port', 'b_device', 'b_port', 'cable_type', 'length_m', 'color', 'status', 'notes']) {
if (form[key]) form[key].value = data[key] == null ? '' : data[key];
}
form.a_side.value = data.a_side || 'front';
form.b_side.value = data.b_side || 'front';
form.label_applied.checked = !!data.label_applied;
form.querySelector('.cs-delete').hidden = !cable;
document.getElementById('cs-next-label').textContent = _cs.next_label;
document.getElementById('cs-cable-title').textContent = cable ? `Edit ${cable.label || 'cable'}` : 'New cable';
fillPorts('a');
fillPorts('b');
lt.modal.open('cs-cable-modal');
}
function openItem(item) {
const form = document.getElementById('cs-item-form');
form.reset();
const data = Object.assign({ kind: 'patch_panel', mount: 'front' }, item || {});
document.getElementById('cs-rack-list').innerHTML = (_cs.racks || []).map(r => `<option value="${esc(r)}">`).join('');
document.getElementById('cs-known-devices').innerHTML = (_cs.devices || []).map(d => `<option value="${esc(d)}">`).join('');
form.chassis.innerHTML = '<option value="">Automatic (faceplate or plain plate)</option>' +
Object.entries(_cs.chassis || {}).map(([k, v]) => `<option value="${esc(k)}">${esc(v)}</option>`).join('');
const shelves = _cs.items.filter(i => i.kind === 'shelf' && (!item || i.id !== item.id));
form.shelf.innerHTML = '<option value="">Not on a shelf</option>' +
shelves.map(i => `<option value="${esc(i.name)}">${esc(i.name)}</option>`).join('');
for (const key of ['id', 'name', 'device', 'kind', 'port_count', 'rack_u', 'rack_height', 'rack', 'mount', 'shelf',
'chassis', 'location', 'notes']) {
form[key].value = data[key] == null ? '' : data[key];
}
if (!item) form.port_count.value = 24;
form.querySelector('.cs-delete').hidden = !item;
document.getElementById('cs-item-title').textContent = item ? `Edit ${item.name}` : 'New panel or item';
lt.modal.open('cs-item-modal');
}
function openPortLabel(itemId, port) {
const form = document.getElementById('cs-port-form');
form.reset();
const item = _cs.items.find(i => String(i.id) === String(itemId));
const lab = _cs.port_labels.find(l => String(l.item_id) === String(itemId) && String(l.port) === String(port));
form.item_id.value = itemId;
form.port.value = port;
form.label.value = lab ? lab.label : '';
form.applied.checked = !!(lab && lab.applied);
document.getElementById('cs-port-title').textContent = `${item ? item.name : 'Panel'} port ${port}`;
lt.modal.open('cs-port-modal');
}
function formData(form, fields) {
const out = {};
for (const f of fields) out[f] = form[f].value;
return out;
}
async function save(fn, okText, modalId) {
try {
await fn();
if (modalId) lt.modal.close(modalId);
lt.toast.success(okText);
await load();
} catch (err) {
lt.toast.error(err.message || 'Save failed');
}
}
async function saveCable(e) {
e.preventDefault();
const form = e.target;
const body = formData(form, ['label', 'a_device', 'a_port', 'a_side', 'b_device', 'b_port', 'b_side',
'cable_type', 'length_m', 'color', 'status', 'notes']);
body.label_applied = form.label_applied.checked;
const id = form.id.value;
await save(() => id ? lt.api.put(`/api/cutsheet/cables/${encodeURIComponent(id)}`, body)
: lt.api.post('/api/cutsheet/cables', body), 'Cable saved', 'cs-cable-modal');
}
async function saveItem(e) {
e.preventDefault();
const form = e.target;
const body = formData(form, ['name', 'device', 'kind', 'port_count', 'rack_u', 'rack_height', 'rack', 'mount', 'shelf',
'chassis', 'location', 'notes']);
const id = form.id.value;
await save(() => id ? lt.api.put(`/api/cutsheet/items/${encodeURIComponent(id)}`, body)
: lt.api.post('/api/cutsheet/items', body), 'Saved', 'cs-item-modal');
}
async function savePortLabel(e) {
e.preventDefault();
const form = e.target;
const url = `/api/cutsheet/items/${encodeURIComponent(form.item_id.value)}/ports/${encodeURIComponent(form.port.value)}`;
await save(() => lt.api.put(url, { label: form.label.value, applied: form.applied.checked }), 'Label saved', 'cs-port-modal');
}
async function markCableApplied(id, applied) {
const c = _cs.cables.find(x => String(x.id) === String(id));
if (!c) return;
const body = {};
for (const k of ['label', 'a_device', 'a_port', 'a_side', 'b_device', 'b_port', 'b_side', 'cable_type', 'length_m', 'color', 'status', 'notes']) {
body[k] = c[k] == null ? '' : c[k];
}
body.label_applied = applied;
await save(() => lt.api.put(`/api/cutsheet/cables/${encodeURIComponent(id)}`, body), `${c.label} marked as labeled`);
}
async function markPortApplied(itemName, port, applied) {
const item = itemByName(itemName);
const lab = item && _cs.port_labels.find(l => l.item_id === item.id && String(l.port) === String(port));
if (!lab) return;
await save(() => lt.api.put(`/api/cutsheet/items/${encodeURIComponent(item.id)}/ports/${encodeURIComponent(port)}`,
{ label: lab.label, applied }), `${lab.label} marked as labeled`);
}
async function importCsv(e, dryRun) {
if (e) e.preventDefault();
const errorsEl = document.getElementById('cs-import-errors');
errorsEl.innerHTML = '';
const fileInput = document.getElementById('cs-import-file');
let text = document.getElementById('cs-import-text').value;
if (fileInput.files.length) text = await fileInput.files[0].text();
let resp, data;
try {
// fetch directly: lt.api keeps only the message, and the row errors matter here
resp = await fetch('/api/cutsheet/import', {
method: 'POST',
headers: Object.assign({ 'Content-Type': 'application/json' }, lt.csrf.headers()),
body: JSON.stringify({ csv: text, dry_run: dryRun }),
});
data = await resp.json();
} catch (err) {
errorsEl.innerHTML = `<div class="val-crit">Import failed: ${esc(err.message)}</div>`;
return;
}
if (!resp.ok) {
errorsEl.innerHTML = `<div class="val-crit">${esc(data.error || `HTTP ${resp.status}`)}</div>` +
(data.errors ? `<ul>${data.errors.map(x => `<li>${esc(x)}</li>`).join('')}</ul>` : '');
return;
}
if (dryRun) {
errorsEl.innerHTML = `<div class="val-good">${esc(data.rows)} row(s) look valid. Nothing imported yet.</div>`;
return;
}
lt.modal.close('cs-import-modal');
lt.toast.success(`Imported: ${data.added} added, ${data.updated} updated`);
await load();
}
// ── Trace mode ──────────────────────────────────────────────────────────
// Snapshot which switch ports are up, then watch for the one that drops when a
// cord is unplugged at the panel. UniFi takes a few seconds to notice.
const TRACE_POLL_MS = 3000;
const TRACE_TIMEOUT_MS = 180000;
let _trace = null;
function renderTracePanels() {
const select = document.getElementById('cs-trace-panel');
if (!select) return;
const panels = _cs.items.filter(i => i.kind === 'patch_panel').sort((a, b) => natural(a.name, b.name));
const keep = select.value;
select.innerHTML = panels.map(p => `<option value="${esc(p.name)}">${esc(p.name)}</option>`).join('');
if (panels.some(p => p.name === keep)) select.value = keep;
document.querySelector('[data-action="trace-start"]').disabled = !panels.length || !!_trace;
if (!panels.length) traceStatus('Add a patch panel first.');
}
function traceStatus(html) {
const el = document.getElementById('cs-trace-status');
if (el) el.innerHTML = html;
}
function portKey(sw, idx) { return JSON.stringify([sw, String(idx)]); }
function upPorts(switches) {
const up = new Set();
for (const [sw, ports] of Object.entries(switches || {})) {
for (const [idx, p] of Object.entries(ports)) if (p.up) up.add(portKey(sw, idx));
}
return up;
}
function traceButtons(running) {
document.querySelector('[data-action="trace-start"]').hidden = running;
document.querySelector('[data-action="trace-stop"]').hidden = !running;
}
function stopTrace() {
if (_trace && _trace.timer) clearTimeout(_trace.timer);
_trace = null;
traceButtons(false);
renderTracePanels();
}
async function startTrace() {
const panel = document.getElementById('cs-trace-panel').value;
const port = String(parseInt(document.getElementById('cs-trace-port').value, 10) || '');
const item = itemByName(panel);
if (!item || !port || Number(port) < 1 || Number(port) > (item.port_count || 0)) {
traceStatus(`<span class="val-crit">Choose a port between 1 and ${esc(item ? item.port_count : '?')}.</span>`);
return;
}
traceButtons(true);
traceStatus('Reading switch ports…');
let live;
try {
live = (await lt.api.get('/api/cutsheet/live-ports')).switches;
} catch (err) {
traceStatus(`<span class="val-crit">${esc(err.message)}</span>`);
traceButtons(false);
return;
}
_trace = { panel, port, baseline: upPorts(live), started: Date.now(), found: null, timer: null };
traceStatus(`Ready. <b>Unplug the cord from ${esc(panel)} port ${esc(port)} now.</b>
Watching ${_trace.baseline.size} linked switch ports… UniFi can take up to about 30 seconds to notice.`);
_trace.timer = setTimeout(pollTrace, TRACE_POLL_MS);
}
async function pollTrace() {
const t = _trace;
if (!t) return;
let live;
try {
live = (await lt.api.get('/api/cutsheet/live-ports')).switches;
} catch (err) {
if (_trace === t) t.timer = setTimeout(pollTrace, TRACE_POLL_MS);
return;
}
if (_trace !== t) return;
const up = upPorts(live);
if (t.found) {
if (up.has(t.found.key)) {
showTraceResult(t, true);
stopTrace();
} else {
t.timer = setTimeout(pollTrace, TRACE_POLL_MS);
}
return;
}
const dropped = [...t.baseline].filter(k => !up.has(k)).map(k => JSON.parse(k));
if (dropped.length === 1) {
const [sw, idx] = dropped[0];
t.found = { key: portKey(sw, idx), sw, idx, name: ((live[sw] || {})[idx] || {}).name || '' };
showTraceResult(t, false);
t.timer = setTimeout(pollTrace, TRACE_POLL_MS);
} else if (dropped.length > 1) {
traceStatus(`<span class="val-warn">Several ports dropped at once, so the cord can't be told apart:</span>
${dropped.map(([sw, idx]) => `${esc(sw)} port ${esc(idx)}`).join(', ')}. Plug everything back in and try again.`);
stopTrace();
} else if (Date.now() - t.started > TRACE_TIMEOUT_MS) {
traceStatus(`No switch port dropped in 3 minutes. If nothing is plugged in at the far end of
${esc(t.panel)} port ${esc(t.port)}, its switch port was never linked; trace that one by hand.`);
stopTrace();
} else {
t.timer = setTimeout(pollTrace, TRACE_POLL_MS);
}
}
function showTraceResult(t, replugged) {
const f = t.found;
const existing = cableAt(f.sw, f.idx, '');
const panelCable = cableAt(t.panel, t.port, 'front');
let action;
if (existing && panelCable && existing.id === panelCable.id) {
action = `<span class="val-good">Matches ${esc(existing.label || 'the cutsheet')}.</span>`;
} else if (existing) {
action = `That switch port is documented as <a class="cs-id" href="#cable-${esc(existing.id)}">${esc(existing.label || 'an unlabeled cable')}</a>
to ${esc(existing.a_device === f.sw ? existing.b_text : existing.a_text)}.
<button type="button" class="lt-btn lt-btn-secondary lt-btn-sm" data-action="edit-cable" data-id="${esc(existing.id)}">Edit it</button>`;
} else {
action = `<button type="button" class="lt-btn lt-btn-primary lt-btn-sm" data-action="trace-record"
data-sw="${esc(f.sw)}" data-idx="${esc(f.idx)}" data-panel="${esc(t.panel)}" data-port="${esc(t.port)}">Record cable</button>`;
}
traceStatus(`
<div class="cs-trace-found">${esc(t.panel)} port ${esc(t.port)} → <b>${esc(f.sw)} port ${esc(f.idx)}</b>${f.name ? ` (${esc(f.name)})` : ''}</div>
<div>${action}</div>
<div class="cs-hint">${replugged ? '<span class="val-good">Plugged back in, link is up again.</span>' : 'Plug the cord back in now.'}</div>`);
}
// ── Wiring ──────────────────────────────────────────────────────────────
document.addEventListener('click', e => {
const btn = e.target.closest('[data-action]');
if (!btn) return;
const action = btn.dataset.action;
if (action === 'new-cable') openCable(null);
else if (action === 'new-item') openItem(null);
else if (action === 'edit-cable') openCable(_cs.cables.find(c => String(c.id) === btn.dataset.id));
else if (action === 'edit-item') openItem(_cs.items.find(i => String(i.id) === btn.dataset.id));
else if (action === 'edit-port-label') openPortLabel(btn.dataset.item, btn.dataset.port);
else if (action === 'print-labels') printLabels();
else if (action === 'trace-start') startTrace();
else if (action === 'trace-stop') { stopTrace(); traceStatus('Stopped.'); }
else if (action === 'trace-record') {
openCable(null, { a_device: btn.dataset.sw, a_port: btn.dataset.idx, b_device: btn.dataset.panel,
b_port: btn.dataset.port, b_side: 'front' });
}
else if (action === 'use-next-label') document.getElementById('cs-label').value = _cs.next_label;
else if (action === 'toggle-suggestions') { _showAllSuggestions = !_showAllSuggestions; renderSuggestions(); }
else if (action === 'import-check') importCsv(null, true);
else if (action === 'add-suggestion') {
const s = _cs.suggestions[Number(btn.dataset.i)];
openCable(null, {
a_device: s.switch, a_port: String(s.port_idx), b_device: s.neighbor, b_port: s.neighbor_port,
cable_type: s.cable_type,
});
} else if (action === 'delete-cable') {
const form = document.getElementById('cs-cable-form');
if (!confirm('Delete this cable record? Retiring it keeps the history visible; deleting removes it.')) return;
save(() => lt.api.delete(`/api/cutsheet/cables/${encodeURIComponent(form.id.value)}`), 'Cable deleted', 'cs-cable-modal');
} else if (action === 'delete-item') {
const form = document.getElementById('cs-item-form');
if (!confirm(`Delete ${form.name.value}?`)) return;
save(() => lt.api.delete(`/api/cutsheet/items/${encodeURIComponent(form.id.value)}`), 'Deleted', 'cs-item-modal');
}
});
document.addEventListener('change', e => {
const t = e.target;
if (t.dataset.action === 'applied-cable') markCableApplied(t.dataset.id, t.checked);
else if (t.dataset.action === 'applied-port') markPortApplied(t.dataset.item, t.dataset.port, t.checked);
});
function printLabels() {
document.body.classList.add('cs-print-labels');
window.print();
document.body.classList.remove('cs-print-labels');
}
function openFromQuery() {
const q = new URLSearchParams(window.location.search);
if (!CS_CAN_EDIT || !q.get('a_device')) return;
openCable(null, { a_device: q.get('a_device'), a_port: q.get('a_port') || '' });
history.replaceState(null, '', window.location.pathname);
}
document.getElementById('cs-filter').addEventListener('input', () => _cs && renderCables());
document.getElementById('cs-status-filter').addEventListener('change', () => _cs && renderCables());
document.getElementById('cs-problems-only').addEventListener('change', () => _cs && renderCables());
if (CS_CAN_EDIT) {
document.getElementById('cs-cable-form').addEventListener('submit', saveCable);
document.getElementById('cs-item-form').addEventListener('submit', saveItem);
document.getElementById('cs-port-form').addEventListener('submit', savePortLabel);
document.getElementById('cs-import-form').addEventListener('submit', e => importCsv(e, false));
for (const end of ['a', 'b']) {
const input = document.querySelector(`#cs-cable-form [name="${end}_device"]`);
input.addEventListener('input', () => fillPorts(end));
input.addEventListener('change', () => fillPorts(end));
}
}
load().then(openFromQuery);
+72 -24
View File
@@ -1,5 +1,5 @@
'use strict';
/* global DEVICE_NAME, deviceUrl, refreshModem, _toIso, fmtRate, fmtErrors, renderPortInspector, selectPortByIdx, highlightSelectedPort */
/* global DEVICE_NAME, CAN_EDIT, deviceUrl, refreshModem, _toIso, fmtRate, fmtErrors, renderPortInspector, selectPortByIdx, highlightSelectedPort, FACEPLATES */
// Per-device page: overview, alerts, and a compact interface/port table. Host
// rows expand in place; switch and router rows open the port inspector panel.
@@ -13,16 +13,16 @@ let _device = null;
// ── Formatting ───────────────────────────────────────────────────────
function fmtSpeed(mbps) {
if (!mbps) return '–';
if (!mbps) return '-';
return mbps >= 1000 ? (mbps / 1000).toFixed(0) + ' Gbps' : mbps + ' Mbps';
}
function fmtUnit(value, unit, digits) {
return value === null || value === undefined ? '–' : `${value.toFixed(digits)} ${unit}`;
return value === null || value === undefined ? '-' : `${value.toFixed(digits)} ${unit}`;
}
function fmtUptime(seconds) {
if (seconds === null || seconds === undefined) return '–';
if (seconds === null || seconds === undefined) return '-';
const d = Math.floor(seconds / 86400), h = Math.floor((seconds % 86400) / 3600);
const m = Math.floor((seconds % 3600) / 60);
return d ? `${d}d ${h}h` : `${h}h ${m}m`;
@@ -108,7 +108,7 @@ function sfpPanel(s) {
<div class="sfp-vendor-row">${vendor}</div>
<div class="sfp-grid">
${item('Temp', tempClass(s.temp_c), fmtUnit(s.temp_c, '°C', 1), 'Module temperature. Normal: below 70°C.')}
${item('Voltage', voltClass(s.voltage_v), fmtUnit(s.voltage_v, 'V', 2), 'Supply voltage. Normal: 3.1–3.5 V.')}
${item('Voltage', voltClass(s.voltage_v), fmtUnit(s.voltage_v, 'V', 2), 'Supply voltage. Normal: 3.1-3.5 V.')}
${item('Bias', '', fmtUnit(s.bias_ma, 'mA', 2), 'Laser bias current. High values may mean an aging laser.')}
${item('TX Power', tx, fmtUnit(s.tx_power_dbm, 'dBm', 2), 'Optical transmit power.', txPct)}
${item('RX Power', rx, fmtUnit(s.rx_power_dbm, 'dBm', 2), 'Optical receive power. Very low values may mean dirty or damaged fiber.', rxPct)}
@@ -127,9 +127,9 @@ function hostRows(interfaces) {
id: name, label: name, up, data: d, sub: d.port_type || '',
detail: `
<div class="link-stats-grid">
${stat('Duplex', esc(d.duplex || '–'), 'Full = both directions at once. Half can cause collisions.')}
${stat('Auto-neg', d.auto_neg === null || d.auto_neg === undefined ? '–' : d.auto_neg ? 'On' : 'Off')}
${stat('Carrier Δ', d.carrier_changes === null || d.carrier_changes === undefined ? '–' : esc(d.carrier_changes), 'Times the link went up or down. High values mean flapping.')}
${stat('Duplex', esc(d.duplex || '-'), 'Full = both directions at once. Half can cause collisions.')}
${stat('Auto-neg', d.auto_neg === null || d.auto_neg === undefined ? '-' : d.auto_neg ? 'On' : 'Off')}
${stat('Carrier Δ', d.carrier_changes === null || d.carrier_changes === undefined ? '-' : esc(d.carrier_changes), 'Times the link went up or down. High values mean flapping.')}
${stat('TX Err/s', fmtErrors(d.tx_errs_rate))}
${stat('RX Err/s', fmtErrors(d.rx_errs_rate))}
${stat('TX Drop/s', fmtErrors(d.tx_drops_rate))}
@@ -171,13 +171,13 @@ function renderTable(rows) {
const d = r.data;
const neighbor = r.neighbor
? (r.neighbor.name ? `<a class="device-link" href="${esc(deviceUrl(r.neighbor.name))}">${esc(r.neighbor.name)}</a>` : esc(r.neighbor.chassis || r.neighbor.port || ''))
: '–';
: '-';
return `
<tr class="device-row${r.up ? '' : ' device-row--down'}"${isPorts ? ` data-port-idx="${esc(r.num)}"` : ''}>
<td><button type="button" class="device-row-toggle" data-row="${esc(r.id)}"${isPorts ? '' : ` aria-expanded="${open}"`} aria-label="Details for ${esc(r.label)}">${open ? '▾' : '▸'}</button></td>
<td><span class="dot-${r.up ? 'up' : 'down'}"></span></td>
<td class="device-row-name">${r.num !== undefined ? `<span class="port-badge port-badge-num">#${esc(r.num)}</span> ` : ''}${esc(r.label)}<div class="device-row-sub">${esc(r.sub)}</div></td>
<td class="device-num">${r.up ? fmtSpeed(d.speed_mbps) : '–'}</td>
<td class="device-num">${r.up ? fmtSpeed(d.speed_mbps) : '-'}</td>
<td class="device-num device-col-wide">${fmtRate(d.rx_bytes_rate)}</td>
<td class="device-num device-col-wide">${fmtRate(d.tx_bytes_rate)}</td>
${isPorts ? `<td class="device-col-wide">${neighbor}</td>` : ''}
@@ -241,7 +241,7 @@ function renderUplinks(d) {
const rows = d.uplinks.map(u => `
<tr>
<td><span class="dot-${u.up ? 'up' : 'down'}"></span></td>
<td>${esc(u.host_interface || '–')}</td>
<td>${esc(u.host_interface || '-')}</td>
<td><a class="device-link" href="${esc(deviceUrl(u.switch))}">${esc(u.switch)}</a></td>
<td><a class="device-link" href="${esc(deviceUrl(u.switch))}#port-${esc(u.port_idx)}">#${esc(u.port_idx)} ${esc(u.port)}</a></td>
<td>${fmtSpeed(u.speed_mbps)}</td>
@@ -259,8 +259,8 @@ function renderWan(d) {
const rows = names.map(n => {
const w = wan[n];
return `<tr><td><span class="dot-${w.up ? 'up' : 'down'}"></span></td><td>${esc(n.toUpperCase())}</td>
<td>${fmtSpeed(w.speed_mbps)}</td><td>${w.latency_ms === null || w.latency_ms === undefined ? '–' : `${esc(w.latency_ms)} ms`}</td>
<td>${w.availability === null || w.availability === undefined ? '–' : `${esc(w.availability)}%`}</td></tr>`;
<td>${fmtSpeed(w.speed_mbps)}</td><td>${w.latency_ms === null || w.latency_ms === undefined ? '-' : `${esc(w.latency_ms)} ms`}</td>
<td>${w.availability === null || w.availability === undefined ? '-' : `${esc(w.availability)}%`}</td></tr>`;
}).join('');
return section('WAN', `<div class="lt-table-wrap"><table class="lt-table">
<caption class="lt-sr-only">WAN connections</caption>
@@ -275,8 +275,8 @@ function renderOutlets(d) {
<tr>
<td><span class="dot-${o.on ? 'up' : 'down'}"></span></td>
<td>#${esc(o.index)}</td>
<td>${esc(o.name || '–')}</td>
<td class="device-num">${o.power_w === null || o.power_w === undefined ? '–' : `${o.power_w.toFixed(1)} W`}</td>
<td>${esc(o.name || '-')}</td>
<td class="device-num">${o.power_w === null || o.power_w === undefined ? '-' : `${o.power_w.toFixed(1)} W`}</td>
<td>${o.auto_power_cycle ? '<span class="lt-badge">auto power-cycle</span>' : ''}</td>
</tr>`).join('');
return section('Outlets', `<div class="lt-table-wrap"><table class="lt-table">
@@ -295,12 +295,13 @@ function renderEvents(events) {
<tr class="${e.resolved_at ? '' : `row-${esc(e.severity)}`}">
<td><span class="lt-badge badge-${e.resolved_at ? 'resolved' : esc(e.severity)}">${esc(e.severity)}</span>${e.is_suppressed && !e.resolved_at ? '<span class="lt-badge badge-suppressed">🔕 sup</span>' : ''}</td>
<td>${esc(e.event_type.replace(/_/g, ' '))}</td>
<td>${esc(e.target_detail || '–')}</td>
<td>${esc(e.target_detail || '-')}</td>
<td class="desc-cell">${esc(e.description || '')}</td>
<td class="ts-cell" title="${esc(e.first_seen || '')}">${esc(lt.time.ago(_toIso(e.first_seen)))}</td>
<td>${e.resolved_at ? `resolved ${esc(lt.time.ago(_toIso(e.resolved_at)))}` : '<strong>active</strong>'}</td>
</tr>`).join('')}</tbody></table></div>`;
return section('Alerts', body);
const more = `<p class="g-section-more"><a href="/events?target=${encodeURIComponent(DEVICE_NAME)}&amp;range=90d">Full alert history for ${esc(DEVICE_NAME)} →</a></p>`;
return section('Alerts', body + more);
}
function currentRows() {
@@ -317,16 +318,61 @@ function renderInterfaces() {
highlightSelectedPort();
}
function updateInterfaceSection(rows, title) {
function updateInterfaceSection(rows, title, hasChassis) {
const section = document.getElementById('device-ports');
section.hidden = !rows.length;
if (!rows.length) return;
section.hidden = !rows.length && !hasChassis;
document.querySelector('.device-port-table').hidden = !rows.length;
if (!rows.length) {
document.getElementById('device-ports-title').textContent = 'Front panel';
return;
}
document.getElementById('device-ports-title').textContent =
`${title} · ${rows.filter(r => r.up).length} of ${rows.length} up`;
document.getElementById('device-table-search').setAttribute('aria-label', `Filter ${title.toLowerCase()}`);
document.getElementById('device-error-count').textContent = rows.filter(rowHasProblem).length;
}
// ── Inventory (HomeBox) link ────────────────────────────────────────────
function inventoryActions(d) {
const inv = d.inventory || {};
const edit = CAN_EDIT
? `<button type="button" class="lt-btn lt-btn-ghost lt-btn-sm" data-action="edit-inventory"
aria-label="${inv.url ? 'Change' : 'Set'} the inventory link for ${esc(d.name)}">✎</button>` : '';
if (inv.url) {
return `<a class="lt-btn lt-btn-secondary lt-btn-sm" href="${esc(inv.url)}" target="_blank" rel="noopener">📦 Inventory ↗</a>${edit}`;
}
if (!inv.search_url) return edit;
return `<a class="lt-btn lt-btn-ghost lt-btn-sm" href="${esc(inv.search_url)}" target="_blank" rel="noopener"
title="No inventory record is linked yet">📦 Find in inventory ↗</a>${edit}`;
}
function openInventoryEditor() {
const inv = (_device && _device.inventory) || {};
const form = document.getElementById('inventory-form');
form.url.value = inv.url || '';
document.getElementById('inventory-search').href = inv.search_url || '#';
lt.modal.open('inventory-modal');
form.url.focus();
}
async function saveInventory(e) {
e.preventDefault();
try {
await lt.api.put(`/api/device/${encodeURIComponent(DEVICE_NAME)}/inventory`, { url: e.target.url.value.trim() });
lt.modal.close('inventory-modal');
lt.toast.success(e.target.url.value.trim() ? 'Inventory link saved' : 'Inventory link removed');
await loadDevice();
} catch (err) {
lt.toast.error(err.message || 'Save failed');
}
}
document.addEventListener('click', e => {
if (e.target.closest('[data-action="edit-inventory"]')) openInventoryEditor();
});
const _inventoryForm = document.getElementById('inventory-form');
if (_inventoryForm) _inventoryForm.addEventListener('submit', saveInventory);
function render(d) {
_device = d;
document.getElementById('device-dot').className = `dot-${d.status || 'unknown'}`;
@@ -335,7 +381,7 @@ function render(d) {
(d.updated ? ` · updated ${new Date(_toIso(d.updated)).toLocaleTimeString()}` : '');
const unifi = d.source === 'unifi';
document.getElementById('device-actions').innerHTML = `
document.getElementById('device-actions').innerHTML = inventoryActions(d) + `
<button class="lt-btn lt-btn-ghost lt-btn-sm btn-suppress" data-sup-type="${unifi ? 'unifi_device' : 'host'}"
data-sup-name="${esc(d.name)}" data-sup-detail="" aria-label="Suppress alerts for ${esc(d.name)}">🔕 Suppress</button>`;
@@ -347,9 +393,11 @@ function render(d) {
renderOutlets(d);
const hasPorts = !!(d.ports && Object.keys(d.ports).length);
document.getElementById('device-inspector').classList.toggle('has-chassis', hasPorts);
updateInterfaceSection(currentRows(), d.ports ? 'Ports' : 'Interfaces');
if (hasPorts) renderPortInspector(d);
// A device like a UPS has a faceplate worth showing but no ports to list
const hasChassis = hasPorts || !!FACEPLATES[d.model];
document.getElementById('device-inspector').classList.toggle('has-chassis', hasChassis);
updateInterfaceSection(currentRows(), d.ports ? 'Ports' : 'Interfaces', hasChassis);
if (hasChassis) renderPortInspector(d);
renderInterfaces();
if (d.kind === 'modem') refreshModem();
+218
View File
@@ -0,0 +1,218 @@
'use strict';
/* global deviceUrl, _toIso */
// Alert history page: renders /api/events/history with filters kept in the URL.
const esc = s => lt.escHtml(s == null ? '' : String(s));
const FILTERS = ['target', 'range', 'type', 'severity', 'status'];
const DEFAULTS = { target: '', range: '7d', type: '', severity: '', status: 'all' };
const RANGE_TEXT = { '24h': '24 hours', '7d': '7 days', '30d': '30 days', '90d': '90 days' };
let _offset = 0;
let _loadSeq = 0;
function typeText(t) {
return String(t || '').replace(/_/g, ' ');
}
function duration(seconds) {
let s = Math.max(0, Math.floor(seconds || 0));
if (s < 60) return `${s} s`;
let m = Math.floor(s / 60);
if (m < 60) return `${m} min`;
let h = Math.floor(m / 60);
m %= 60;
if (h < 48) return m ? `${h} h ${m} min` : `${h} h`;
const d = Math.floor(h / 24);
h %= 24;
return h ? `${d} d ${h} h` : `${d} d`;
}
function when(iso) {
if (!iso) return '-';
const d = new Date(_toIso(iso));
if (isNaN(d)) return esc(iso);
const text = d.toLocaleString([], { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' });
return `<span title="${esc(d.toLocaleString())}">${esc(text)}</span>`;
}
function ticketLink(id) {
if (!id) return '<span class="val-neutral">-</span>';
const base = (typeof GANDALF_CONFIG !== 'undefined' && GANDALF_CONFIG.ticket_web_url) || '';
return base ? `<a href="${esc(base + id)}" target="_blank" rel="noopener">#${esc(id)}</a>` : `#${esc(id)}`;
}
function filters() {
const f = {};
FILTERS.forEach(k => { f[k] = document.getElementById(`ev-${k}`).value.trim(); });
return f;
}
function readUrl() {
const q = new URLSearchParams(location.search);
FILTERS.forEach(k => {
const el = document.getElementById(`ev-${k}`);
const v = q.get(k);
if (v == null) return;
if (el.tagName === 'SELECT' && ![...el.options].some(o => o.value === v)) {
// An alert type from a link may not be in the list until data arrives
if (k === 'type') el.add(new Option(typeText(v), v));
else return;
}
el.value = v;
});
}
function writeUrl(f) {
const q = new URLSearchParams();
FILTERS.forEach(k => { if (f[k] && f[k] !== DEFAULTS[k]) q.set(k, f[k]); });
const qs = q.toString();
history.replaceState(null, '', qs ? `?${qs}` : location.pathname);
document.getElementById('ev-clear').hidden = !FILTERS.some(k => k !== 'range' && f[k] && f[k] !== DEFAULTS[k]);
}
function setFilter(changes) {
Object.entries(changes).forEach(([k, v]) => {
const el = document.getElementById(`ev-${k}`);
if (el.tagName === 'SELECT' && v && ![...el.options].some(o => o.value === v)) el.add(new Option(typeText(v), v));
el.value = v;
});
_offset = 0;
load();
}
function fillTypes(types) {
const sel = document.getElementById('ev-type');
const current = sel.value;
sel.innerHTML = '<option value="">All alert types</option>' +
types.map(t => `<option value="${esc(t)}">${esc(typeText(t))}</option>`).join('');
if (current && !types.includes(current)) sel.add(new Option(typeText(current), current));
sel.value = current;
}
function renderSummary(data, f) {
const open = data.events.filter(e => !e.resolved_at).length;
const chips = [
`<span class="cs-chip"><b>${data.total}</b> alert${data.total === 1 ? '' : 's'} in the last ${esc(RANGE_TEXT[f.range] || f.range)}</span>`,
];
if (open && data.offset === 0) chips.push(`<span class="cs-chip cs-chip-bad"><b>${open}</b> open now</span>`);
Object.entries(data.by_type || {}).forEach(([t, n]) => {
const on = f.type === t;
chips.push(`<button type="button" class="cs-chip ev-type-chip${on ? ' active' : ''}" data-type="${esc(on ? '' : t)}"
aria-pressed="${on}"><b>${n}</b> ${esc(typeText(t))}</button>`);
});
document.getElementById('ev-summary').innerHTML = chips.join('');
}
function renderFlappers(rows) {
const sec = document.getElementById('ev-flappers-section');
sec.hidden = !rows.length;
if (!rows.length) return;
document.getElementById('ev-flappers').innerHTML = `<div class="lt-table-wrap"><table class="lt-table ev-cards">
<caption class="lt-sr-only">Alerts that fired more than once</caption>
<thead><tr><th>Alert</th><th>Target</th><th>Times</th><th>Total time</th><th>Last started</th><th></th></tr></thead>
<tbody>${rows.map(r => `
<tr>
<td class="ev-c-type">${esc(typeText(r.event_type))}${r.open_now ? ' <span class="lt-badge badge-critical">open</span>' : ''}</td>
<td class="ev-c-target"><a class="device-link" href="${esc(deviceUrl(r.target_name))}">${esc(r.target_name)}</a>
${r.target_detail ? `<span class="cs-port">${esc(r.target_detail)}</span>` : ''}</td>
<td data-label="Times"><strong>${r.n}</strong></td>
<td data-label="Total">${esc(duration(r.total_s))}</td>
<td class="ts-cell" data-label="Last">${when(r.last_seen)}</td>
<td class="ev-c-action"><button type="button" class="lt-btn lt-btn-secondary lt-btn-sm" data-show-type="${esc(r.event_type)}"
data-show-target="${esc(r.target_name)}">Show these</button></td>
</tr>`).join('')}</tbody></table></div>`;
}
function renderTable(data) {
document.getElementById('ev-count').textContent = data.total;
const wrap = document.getElementById('ev-table');
if (!data.events.length) {
wrap.innerHTML = '<div class="lt-empty-state lt-empty-state--sm"><div class="lt-empty-state-icon">✔</div>' +
'<div class="lt-empty-state-title">No alerts match</div></div>';
document.getElementById('ev-pager').innerHTML = '';
return;
}
wrap.innerHTML = `<div class="lt-table-wrap"><table class="lt-table ev-table ev-cards">
<caption class="lt-sr-only">Alert history</caption>
<thead><tr><th>State</th><th>Type</th><th>Target</th><th>Started</th><th>Lasted</th>
<th title="Consecutive failed checks">Checks</th><th>Ticket</th><th>Description</th></tr></thead>
<tbody>${data.events.map(e => {
const open = !e.resolved_at;
return `<tr class="${open ? `row-${esc(e.severity)}` : ''}">
<td class="ev-c-state"><span class="lt-badge badge-${open ? esc(e.severity) : 'neutral'}">${open ? 'open' : 'cleared'}</span></td>
<td class="ev-c-type"><button type="button" class="ev-link" data-show-type="${esc(e.event_type)}"
title="Only show ${esc(typeText(e.event_type))}">${esc(typeText(e.event_type))}</button></td>
<td class="ev-c-target"><a class="device-link" href="${esc(deviceUrl(e.target_name))}">${esc(e.target_name)}</a>
${e.target_detail ? `<span class="cs-port">${esc(e.target_detail)}</span>` : ''}</td>
<td class="ts-cell" data-label="Started">${when(e.first_seen)}</td>
<td data-label="Lasted">${esc(duration(e.duration_s))}${open ? ' <span class="val-neutral">so far</span>' : ''}</td>
<td data-label="Checks">${esc(e.consecutive_failures)}</td>
<td data-label="Ticket">${ticketLink(e.ticket_id)}</td>
<td class="desc-cell ev-c-desc" title="${esc(e.description || '')}">${esc(e.description || '')}</td>
</tr>`;
}).join('')}</tbody></table></div>`;
const end = data.offset + data.events.length;
const prev = data.offset > 0;
const next = end < data.total;
document.getElementById('ev-pager').innerHTML = (prev || next) ? `
<button type="button" class="lt-btn lt-btn-secondary lt-btn-sm" data-page="${data.offset - data.page_size}" ${prev ? '' : 'disabled'}>← Newer</button>
<span>${data.offset + 1}-${end} of ${data.total}</span>
<button type="button" class="lt-btn lt-btn-secondary lt-btn-sm" data-page="${end}" ${next ? '' : 'disabled'}>Older →</button>` : '';
}
async function load() {
const f = filters();
writeUrl(f);
const q = new URLSearchParams();
FILTERS.forEach(k => { if (f[k]) q.set(k, f[k]); });
if (_offset) q.set('offset', _offset);
const seq = ++_loadSeq;
try {
const data = await lt.api.get(`/api/events/history?${q}`);
if (seq !== _loadSeq) return; // a newer filter change is already loading
fillTypes(data.types || []);
renderSummary(data, f);
renderFlappers(data.flappers || []);
renderTable(data);
} catch (err) {
if (seq !== _loadSeq) return;
document.getElementById('ev-table').innerHTML =
`<div class="lt-empty-state lt-empty-state--sm"><div class="lt-empty-state-title">Could not load alerts</div>
<div class="lt-empty-state-text">${esc(err.message || err)}</div></div>`;
}
}
let _typing = null;
document.getElementById('ev-target').addEventListener('input', () => {
clearTimeout(_typing);
_typing = setTimeout(() => { _offset = 0; load(); }, 300);
});
document.getElementById('ev-filters').addEventListener('change', e => {
if (e.target.id === 'ev-target') return;
_offset = 0;
load();
});
document.getElementById('ev-filters').addEventListener('submit', e => { e.preventDefault(); _offset = 0; load(); });
document.getElementById('ev-clear').addEventListener('click', () => {
setFilter({ target: '', type: '', severity: '', status: 'all' });
});
document.addEventListener('click', e => {
const typeChip = e.target.closest('.ev-type-chip');
if (typeChip) return setFilter({ type: typeChip.dataset.type });
const show = e.target.closest('[data-show-type]');
if (show) {
const changes = { type: show.dataset.showType };
if (show.dataset.showTarget) changes.target = show.dataset.showTarget;
return setFilter(changes);
}
const page = e.target.closest('[data-page]');
if (page && !page.disabled) {
_offset = Math.max(0, parseInt(page.dataset.page, 10) || 0);
load();
document.getElementById('ev-count').scrollIntoView({ block: 'nearest' });
}
});
readUrl();
load();
+587
View File
@@ -0,0 +1,587 @@
'use strict';
/* exported renderFaceplate, faceplateScrollLeft, FACEPLATES */
// Realistic front panels, drawn as SVG from each model's real geometry.
// Coordinates are traced from reference images. Keys match UniFi's model code.
//
// To add a model, add an entry to FACEPLATES:
// width, height viewBox size, in proportion to the real device
// label name used for screen readers
// frameClass how a narrow panel adapts: fp-crop-* (style.css), fp-scroll, fp-desk or fp-fit
// noBody decor() draws the whole body itself
// scrollX left edge of the port area, shown first in an fp-scroll panel
// legend [[LED class, text], ...]
// decor(ctx) SVG for the fixed parts, ctx: { online }
// ports { idx, type: 'rj45'|'sfp', x, y, ... } for each port
// outlets { idx, kind, x, y, w, h, label } for each power outlet
// Models without an entry use the plain block layout in port-inspector.js.
// LED colors come from each model's quick start guide.
const FP_LED_RULES = {
rj45(mbps) { return mbps >= 1000 ? 'green' : 'amber'; },
sfp(mbps) { return mbps >= 10000 ? 'white' : 'green'; },
// USW Flex: green at every speed
linkOnly() { return 'green'; },
};
function faceplateLed(port, rule) {
if (!port || !port.up) return 'off';
if (!port.speed_mbps) return 'unknown';
return FP_LED_RULES[rule](port.speed_mbps);
}
function ledActivityClass(port) {
if (!port || !port.up) return '';
return (port.tx_bytes_rate || port.rx_bytes_rate) ? ' fp-led-active' : '';
}
const hasPoe = port => !!(port && port.poe_power > 0);
// An RJ45 jack seen head-on, centered on (0,0) with the clip notch up.
// A cable is drawn in the jack when the port has link.
function rj45Svg(port, p) {
const led = faceplateLed(port, p.rule || 'rj45');
const plug = port && port.up
? `<rect class="fp-plug" x="-12" y="-6.5" width="24" height="14" rx="1"/>
<rect class="fp-plug-clip" x="-5" y="-14" width="10" height="8"/>`
: `<g class="fp-contacts">${[-9, -6, -3, 0, 3, 6, 9].map(x => `<rect x="${x - .6}" y="-8" width="1.2" height="4"/>`).join('')}</g>`;
const leftLed = p.poeLed ? `fp-led fp-led-${hasPoe(port) ? 'amber' : 'off'}` : 'fp-led-idle';
return `
<path class="fp-jack" d="M-15 -8.5 H-7.5 V-16 H7.5 V-8.5 H15 V-3 H16 V1 H15 V9 H-15 V1 H-16 V-3 H-15 Z"/>
${plug}
<rect class="${leftLed}" x="-16" y="-14" width="7.5" height="3.2" rx=".8"/>
<rect class="fp-led fp-led-${led}${ledActivityClass(port)}" x="8.5" y="-14" width="7.5" height="3.2" rx=".8"/>`;
}
// An SFP+ cage seen head-on. Fills with a module when the port has link.
// What sits in a cage: 'empty', 'optic', 'dac', or 'module' when the module
// doesn't say what it is. Without module data (older snapshots, or a gateway
// that doesn't report it) a linked port is shown as an optic, as before.
function sfpModuleKind(port) {
const sfp = port && port.sfp;
if (sfp) return !sfp.found ? 'empty' : (sfp.kind || 'module');
return port && port.up ? 'optic' : 'empty';
}
function sfpSvg(port, w, h) {
const kind = sfpModuleKind(port);
const sfp = port && port.sfp;
const fault = sfp && (sfp.rx_fault || sfp.tx_fault) ? ' fp-module-fault' : '';
const body = `<rect class="fp-module${fault}" x="2.5" y="2.5" width="${w - 5}" height="${h - 5}" rx="1"/>`;
let inner;
if (kind === 'optic') {
inner = `${body}
<rect class="fp-module-lc" x="6.5" y="6" width="9" height="${h - 12}" rx="1.2"/>
<rect class="fp-module-lc" x="${w - 15.5}" y="6" width="9" height="${h - 12}" rx="1.2"/>`;
} else if (kind === 'dac') {
// A DAC's cable leaves through a boot in the middle of the module
inner = `${body}
<rect class="fp-dac-boot" x="${w / 2 - 7}" y="4.5" width="14" height="${h - 9}" rx="2.5"/>
<circle class="fp-dac-cable" cx="${w / 2}" cy="${h / 2}" r="3.2"/>`;
} else if (kind === 'module') {
// Present but unidentified: the module body with its pull tab, no connector detail
inner = `${body}
<rect class="fp-cage-rail" x="${w / 2 - 6}" y="${h / 2 - 1.5}" width="12" height="3" rx="1"/>`;
} else {
inner = `<path class="fp-cage-spring" d="M4 5 H${w - 4} M4 ${h - 5} H${w - 4}"/>
<rect class="fp-cage-rail" x="${w / 2 - 8}" y="${h / 2 - 2}" width="16" height="4" rx="1"/>`;
}
return `<rect class="fp-cage" width="${w}" height="${h}" rx="1"/>${inner}`;
}
// The cages' LEDs sit between them: left ▲ for the top port, right ▼ for the bottom.
function sfpLedSvg(p, port) {
const [x, y] = p.led;
const points = p.flip ? `${x - 2.4},${y - 1.8} ${x + 2.4},${y - 1.8} ${x},${y + 2}`
: `${x - 2.4},${y + 1.8} ${x + 2.4},${y + 1.8} ${x},${y - 2}`;
return `<polygon class="fp-led fp-led-${faceplateLed(port, 'sfp')}${ledActivityClass(port)}" points="${points}"/>`;
}
function portLabelSvg(p, port) {
if (!p.label) return '';
const [x, y] = p.label;
const size = p.labelSize ? ` style="font-size:${p.labelSize}px"` : '';
const bolt = hasPoe(port) && !p.poeLed
? `<path class="fp-bolt" transform="translate(${x + 8} ${y - 8})" d="M3 0 L0 5 H2.2 L1.4 9 L5 3.6 H2.8 L4 0 Z"/>`
: '';
return `<text class="fp-label" x="${x}" y="${y}" text-anchor="middle"${size}>${p.text || p.idx}</text>${bolt}`;
}
// Cutsheet status dot in a port's corner: ok (matches), bad (mismatch), doc (documented, not confirmed)
function cutsheetMarkSvg(mark, x, y) {
if (!mark) return '';
return `<circle class="fp-mark fp-mark-${mark}" cx="${x}" cy="${y}" r="3.2"/>`;
}
function faceplatePortSvg(p, port, swName, title, mark) {
// The drawn port number can differ from the index UniFi reports (see anyPort)
const idx = (p.anyPort && port) ? port.port_idx : p.idx;
const attrs = `class="fp-port${port && port.up ? ' fp-up' : ''}" data-switch="${lt.escHtml(swName)}" data-port-idx="${idx}"
data-action="select-port" role="button" tabindex="0" aria-label="${title}"`;
if (p.type === 'sfp') {
return `<g ${attrs} transform="translate(${p.x} ${p.y})">
<title>${title}</title>
${sfpSvg(port, p.w, p.h)}
<rect class="fp-hit" x="-1" y="-1" width="${p.w + 2}" height="${p.h + 2}" rx="2"/>
${cutsheetMarkSvg(mark, p.w - 3, 3)}
</g>
${sfpLedSvg(p, port)}${portLabelSvg(p, port)}`;
}
const scale = p.scale || 1;
return `<g ${attrs} transform="translate(${p.x} ${p.y}) scale(${scale})">
<title>${title}</title>
<g transform="scale(1 ${p.flip ? -1 : 1})">${rj45Svg(port, p)}</g>
<rect class="fp-hit" x="-18" y="-${p.flip ? 11 : 17}" width="36" height="28" rx="2"/>
${cutsheetMarkSvg(mark, 14, p.flip ? 13 : -13)}
</g>${portLabelSvg(p, port)}`;
}
// ── Power outlets ────────────────────────────────────────────────────────
function outletFaceSvg(kind, w, h, idx) {
const cx = w / 2, cy = h / 2;
if (kind === 'tile') {
return `<rect class="fp-tile" width="${w}" height="${h}" rx="2"/>
<text class="fp-tile-num" x="${cx}" y="${cy + 3.5}" text-anchor="middle">${idx}</text>`;
}
if (kind === 'usbc') {
return `<rect class="fp-usbc" width="${w}" height="${h}" rx="${w / 2}"/>
<rect class="fp-usbc-tongue" x="${cx - 1}" y="4" width="2" height="${h - 8}" rx="1"/>`;
}
const face = `<rect class="fp-outlet-face" width="${w}" height="${h}" rx="3"/>`;
if (kind === 'horizontal') {
return `${face}
<rect class="fp-slot" x="${cx - 24}" y="${cy - 15}" width="19" height="4.5" rx=".6"/>
<rect class="fp-slot" x="${cx - 24}" y="${cy + 10.5}" width="19" height="4.5" rx=".6"/>
<path class="fp-slot" d="M${cx + 12} ${cy - 8} h13 v16 h-13 a8 8 0 0 1 0 -16 Z"/>`;
}
const tee = kind === 'vertical-20'
? `<rect class="fp-slot" x="${cx + 12}" y="${cy - 8}" width="10" height="4"/>` : '';
return `${face}
<rect class="fp-slot" x="${cx - 19}" y="${cy - 23}" width="5" height="19" rx=".6"/>
<rect class="fp-slot" x="${cx + 14}" y="${cy - 23}" width="5" height="19" rx=".6"/>
${tee}
<path class="fp-slot" d="M${cx - 7.5} ${cy + 22} v-9 a7.5 7.5 0 0 1 15 0 v9 Z"/>`;
}
function outletTitle(o, data) {
const parts = [`Outlet ${o.idx}`];
if (data) {
if (data.name && data.name !== parts[0]) parts.push(data.name);
parts.push(data.on === false ? 'off' : 'on');
if (data.power_w != null) parts.push(`${data.power_w.toFixed(1)} W`);
if (data.auto_power_cycle) parts.push('auto power-cycle');
}
return lt.escHtml(parts.join(' · '));
}
function faceplateOutletSvg(o, data) {
const title = outletTitle(o, data);
const off = data && data.on === false;
const face = outletFaceSvg(o.kind, o.w, o.h, o.idx);
const group = `<g class="fp-outlet${off ? ' fp-outlet-is-off' : ''}" tabindex="0" role="img" aria-label="${title}" transform="translate(${o.x} ${o.y})">
<title>${title}</title>
${o.flip ? `<g transform="rotate(180 ${o.w / 2} ${o.h / 2})">${face}</g>` : face}
<rect class="fp-hit" x="-1.5" y="-1.5" width="${o.w + 3}" height="${o.h + 3}" rx="3"/>
</g>`;
if (!o.label) return group;
const [lx, ly] = o.label;
// An outlet can read 0 W while its device runs, so only the relay state means off
const state = `<circle class="fp-outlet-state ${off ? 'fp-state-off' : data ? 'fp-state-on' : ''}" cx="${lx - 9}" cy="${ly - 3}" r="2.2"/>`;
const cycle = data && data.auto_power_cycle
? `<path class="fp-cycle" transform="translate(${lx + 8} ${ly - 7})" d="M7 1.5 A3.5 3.5 0 1 0 8 5 M7 0 V2.5 H4.5"/>` : '';
return `${group}${state}<text class="fp-label" x="${lx}" y="${ly}" text-anchor="middle">${o.idx}</text>${cycle}`;
}
// A jack Gandalf gets no data for. Hovering or focusing it says what it is.
function fpPassiveJack(x, y, flip, description) {
const title = lt.escHtml(description);
return `<g class="fp-outlet fp-static" tabindex="0" role="img" aria-label="${title}" transform="translate(${x} ${y})">
<title>${title}</title>
<g transform="scale(1 ${flip ? -1 : 1})">${rj45Svg(null, {})}</g>
<rect class="fp-hit" x="-18" y="-${flip ? 11 : 17}" width="36" height="28" rx="2"/>
</g>`;
}
// ── Shared drawing helpers ───────────────────────────────────────────────
const fpGlobe = (x, y) => `<g class="fp-globe" transform="translate(${x} ${y})">
<circle r="3.4"/><ellipse rx="1.5" ry="3.4"/><path d="M-3.4 0 H3.4"/></g>`;
const fpVents = (spans, y, h = 2.6) => spans
.map(([a, b]) => `<rect class="fp-vent" x="${a}" y="${y}" width="${b - a}" height="${h}" rx="${h / 2}"/>`).join('');
const fpReset = (x, y) => `<circle class="fp-reset" cx="${x}" cy="${y}" r="2.2"/>
<text class="fp-label fp-label-sm" x="${x + 5}" y="${y + 2.5}">RESET</text>`;
// The status screen on UniFi switches: four quadrants around a center dot
function fpQuadScreen(x, y, s) {
const c = s / 2;
const icons = [[.24, .24], [.76, .24], [.24, .76], [.76, .76]]
.map(([a, b]) => `<circle class="fp-screen-icon" cx="${s * a}" cy="${s * b}" r="${s * .07}"/>`).join('');
return `<g transform="translate(${x} ${y})">
<rect class="fp-screen" width="${s}" height="${s}" rx="3"/>
<path class="fp-screen-grid" d="M${c} 3 V${s - 3} M3 ${c} H${s - 3}"/>
${icons}
<circle class="fp-screen-dot" cx="${c}" cy="${c}" r="${s * .11}"/>
</g>`;
}
// The model name printed under a UniFi screen: centred on the screen, first word bold and
// second word light ("USW Pro", "NVR Pro"), as on the real units. `bolt` adds the PoE mark.
function fpModel(cx, y, bold, light = '', { size = 7.5, bolt = false } = {}) {
const chars = bold.length + (light ? light.length + 1 : 0);
const boltW = bolt ? size * 1.3 : 0;
const textW = chars * size * 0.6;
const x = cx - boltW / 2;
const mark = bolt
? `<g transform="translate(${x + textW / 2 + size * 0.75} ${y - size * 0.4})">
<circle class="fp-brand-bolt-ring" r="${size * 0.62}"/>
<path class="fp-brand-bolt" transform="scale(${size / 11})" d="M1 -5 L-3 1 H0 L-1 5 L3 -1 H0 Z"/></g>`
: '';
return `<text class="fp-brand" x="${x}" y="${y}" text-anchor="middle" style="font-size:${size}px">${bold}${light
? `<tspan class="fp-brand-light" dx="${size * 0.25}">${light}</tspan>` : ''}</text>${mark}`;
}
// Two rows of jacks, odd numbers on top: how UniFi rack switches number ports
function rj45Pairs(columns, rows) {
return columns.flatMap((x, i) => [
{ idx: 2 * i + 1, type: 'rj45', x, y: rows.top, label: [x, rows.topLabel] },
{ idx: 2 * i + 2, type: 'rj45', x, y: rows.bottom, flip: true, label: [x, rows.bottomLabel] },
]);
}
function sfpPairs(columns, g) {
return columns.flatMap((x, i) => [
{ idx: g.first + 2 * i, type: 'sfp', x, y: g.top, w: g.w, h: g.h,
led: [x + g.w / 2 - g.ledGap, g.ledY], label: g.topLabel && [x + g.w / 2, g.topLabel] },
{ idx: g.first + 2 * i + 1, type: 'sfp', x, y: g.bottom, w: g.w, h: g.h, flip: true,
led: [x + g.w / 2 + g.ledGap, g.ledY], label: g.bottomLabel && [x + g.w / 2, g.bottomLabel] },
]);
}
const roleRange = (from, to, role) => Object.fromEntries(
Array.from({ length: to - from + 1 }, (_, i) => [from + i, role]));
const LEGEND_RJ45 = [['off', 'no link'], ['amber', '10/100M'], ['green', '1G']];
const FACEPLATES = {
// https://dl.ui.com/qsg/UDM-Pro/UDM-Pro_EN.html
UDMPRO: {
width: 1065, height: 106, frameClass: 'fp-crop-udmpro',
label: 'Dream Machine Pro',
legend: [...LEGEND_RJ45, ['white', '10G']],
roles: {
...roleRange(1, 8, 'RJ45 LAN'),
9: 'RJ45 Internet', 10: 'SFP+ Internet', 11: 'SFP+ LAN',
},
ports: [
...rj45Pairs([760.5, 798, 835.5, 873], { top: 40, bottom: 66, topLabel: 18.5, bottomLabel: 93.5 }),
{ idx: 9, type: 'rj45', x: 948, y: 69 },
{ idx: 10, type: 'sfp', x: 975, y: 22, w: 35, h: 23.5, led: [985, 52.5] },
{ idx: 11, type: 'sfp', x: 975, y: 59.5, w: 35, h: 23.5, flip: true, led: [1000, 52.5] },
],
decor() {
return `${fpVents([[90, 268], [277, 452], [462, 638], [647, 822], [833, 1010]], 8)}
<rect class="fp-screen" x="15" y="25" width="56" height="56" rx="3"/>
<circle class="fp-screen-ring" cx="43" cy="51" r="13"/>
<circle class="fp-screen-dot" cx="43" cy="51" r="4.5"/>
${fpModel(43, 94, 'UDM', 'Pro')}
<rect class="fp-bay" x="447" y="19" width="259" height="66" rx="1.5"/>
<rect class="fp-bay-edge" x="447.8" y="19.8" width="3.5" height="64.4"/>
<circle class="fp-bay-led" cx="681" cy="52" r="1.6"/>
<rect class="fp-block" x="740" y="22" width="153" height="61.5" rx="1"/>
<rect class="fp-block" x="928" y="50" width="40" height="33.5" rx="1"/>
<rect class="fp-divider" x="975" y="45.5" width="35" height="14"/>
<text class="fp-label" x="941" y="93.5" text-anchor="middle">9</text>${fpGlobe(951, 90.5)}
<text class="fp-label" x="987" y="18.5" text-anchor="middle">10</text>${fpGlobe(999, 15.5)}
<text class="fp-label" x="992.5" y="93.5" text-anchor="middle">11</text>
${fpReset(1026, 91)}`;
},
},
// UniFi NVR Pro, 2U. Layout from the CC0 NetBox devicetype-library front image
// (elevation-images/Ubiquiti/ubiquiti-unifi-protect-network-video-recorder-pro.front.png):
// touchscreen top left, bays 1-3 on top and 4-7 below, RJ45 (1) and SFP+ (2) top right.
// UniFi Network doesn't list a Protect NVR, so on the rack it is picked by Front drawing;
// if it is ever reported as UNVRPRO its ports go live like any other.
UNVRPRO: {
width: 1167, height: 230, frameClass: 'fp-scroll', scrollX: 700,
label: 'UniFi NVR Pro',
legend: [...LEGEND_RJ45, ['white', '10G']],
roles: { 1: 'RJ45 1G', 2: 'SFP+ 10G' },
ports: [
{ idx: 1, type: 'rj45', x: 1040, y: 74, scale: 1.3, label: [1040, 44] },
{ idx: 2, type: 'sfp', x: 1072, y: 61, w: 40, h: 27, led: [1092, 96], label: [1092, 44] },
],
decor() {
const spans = [[97, 293], [302, 498], [507, 703], [712, 908], [916, 1112]];
const bay = (x, y, n) => `<rect class="fp-bay" x="${x}" y="${y}" width="283" height="76" rx="1.5"/>
<rect class="fp-bay-edge" x="${x + 1}" y="${y + 1}" width="4.5" height="74"/>
<circle class="fp-bay-led" cx="${x + 255}" cy="${y + 38}" r="2.2"/>
<text class="fp-label" x="${x + 141}" y="${y + 89}" text-anchor="middle">${n}</text>`;
return `${fpVents(spans, 8, 4)}${fpVents(spans, 216, 4)}
${fpQuadScreen(14, 33, 62)}${fpModel(45, 111, 'NVR', 'Pro')}
${[97, 384, 669].map((x, i) => bay(x, 27, i + 1)).join('')}
${[12, 299, 585, 871].map((x, i) => bay(x, 125, i + 4)).join('')}
<rect class="fp-block" x="1014" y="52" width="104" height="44" rx="1"/>
${fpReset(1124, 219)}`;
},
},
// Port layout and LED colors: https://dl.ui.com/qsg/USW-Pro-24/USW-Pro-24_EN.html
// (the non-PoE sibling). PoE draw has no documented LED, so it is a bolt by the number.
US24PRO: {
width: 1179, height: 113, frameClass: 'fp-scroll', scrollX: 550,
label: 'USW Pro 24 PoE',
legend: [...LEGEND_RJ45, ['white', '10G'], ['poe', 'PoE in use']],
roles: { ...roleRange(1, 24, 'RJ45'), 25: 'SFP+', 26: 'SFP+' },
ports: [
...rj45Pairs([586.7, 624.2, 661.7, 699.2, 736.7, 774.2, 820, 857.5, 895, 932.5, 970, 1007.5],
{ top: 38, bottom: 69, topLabel: 15.5, bottomLabel: 98 }),
...sfpPairs([1083], { first: 25, top: 19, bottom: 61, w: 39, h: 26, ledY: 53.5, ledGap: 10.5,
topLabel: 15.5, bottomLabel: 98 }),
],
decor() {
return `${fpVents([[98, 298], [304, 504], [512, 710], [717, 917], [923, 1122]], 3)}
${fpQuadScreen(15, 23, 62)}${fpModel(46, 99, 'USW', 'Pro', { bolt: true })}
<rect class="fp-block" x="563" y="19" width="234" height="69" rx="1"/>
<rect class="fp-block" x="797.5" y="19" width="233" height="69" rx="1"/>
<rect class="fp-divider" x="1083" y="45" width="39" height="16"/>
${fpReset(1140, 97)}`;
},
},
// No quick start guide was available: layout from a reference image. LED colors
// are taken from the SFP+ ports of the USW Pro 24 guide.
USL8A: {
width: 1115, height: 110, frameClass: 'fp-crop-agg',
label: 'USW Aggregation',
legend: [['off', 'no link'], ['green', '1G'], ['white', '10G']],
roles: roleRange(1, 8, 'SFP+'),
ports: sfpPairs([876.4, 925.6, 975.6, 1025], {
first: 1, top: 21.6, bottom: 61.6, w: 36, h: 25, ledY: 54.5, ledGap: 9.5, topLabel: 17, bottomLabel: 95,
}),
decor() {
const dividers = [876.4, 925.6, 975.6, 1025]
.map(x => `<rect class="fp-divider" x="${x}" y="46.6" width="36" height="15"/>`).join('');
return `${fpVents([[91, 280], [287, 476], [482, 671], [678, 867], [874, 1062]], 7)}
${fpQuadScreen(12, 25, 58)}${fpModel(41, 96, 'USW')}
${dividers}
<rect class="fp-speed-bar" x="874" y="99" width="188" height="4" rx="1"/>
${fpReset(1078.6, 95)}`;
},
},
// https://dl.ui.com/qsg/USW-Flex/USW-Flex_EN.html
USF5P: {
width: 553, height: 128, frameClass: 'fp-desk', noBody: true,
label: 'USW Flex',
legend: [['off', 'no link'], ['green', 'link'], ['amber', 'PoE out']],
roles: { 1: 'RJ45, PoE in', ...roleRange(2, 5, 'RJ45, PoE out') },
ports: [170, 225, 280, 335, 391].map((x, i) => ({
idx: i + 1, type: 'rj45', x, y: 60, scale: 1.6, rule: 'linkOnly', poeLed: i > 0,
label: [x, 106], labelSize: 12,
})),
decor() {
return `<rect class="fp-body-white" x="66" y="6" width="422" height="110" rx="18"/>
<rect class="fp-frame-grey" x="130" y="26" width="291" height="66" rx="3"/>
<rect class="fp-foot" x="115" y="116" width="44" height="6" rx="2"/>
<rect class="fp-foot" x="395" y="116" width="44" height="6" rx="2"/>`;
},
},
// https://dl.ui.com/qsg/USW-Flex-Mini/USW-Flex-Mini_EN.html
USMINI: {
width: 663, height: 160, frameClass: 'fp-desk', noBody: true,
label: 'USW Flex Mini',
legend: LEGEND_RJ45,
roles: { 1: 'RJ45, PoE in', ...roleRange(2, 5, 'RJ45') },
ports: [132, 235, 332, 430, 527].map((x, i) => ({
idx: i + 1, type: 'rj45', x, y: 73, scale: 2.4,
label: [x, 134], labelSize: 14, text: i === 0 ? 'PoE IN' : String(i + 1),
})),
decor() {
return `<rect class="fp-body-white" x="2" y="14" width="659" height="134" rx="26"/>
<rect class="fp-frame-grey" x="82" y="28" width="98" height="84" rx="2"/>
<rect class="fp-frame-grey" x="184" y="28" width="392" height="84" rx="2"/>
<circle class="fp-reset" cx="62" cy="68" r="3"/>
<text class="fp-label fp-label-sm" x="590" y="52">LINK</text>
<rect class="fp-key" x="590" y="59" width="6" height="6"/><text class="fp-label fp-label-sm" x="600" y="65">DOWN</text>
<rect class="fp-key fp-key-amber" x="590" y="71" width="6" height="6"/><text class="fp-label fp-label-sm" x="600" y="77">10/100</text>
<rect class="fp-key fp-key-green" x="590" y="83" width="6" height="6"/><text class="fp-label fp-label-sm" x="600" y="89">1000</text>`;
},
},
// Layout from a reference image, no quick start guide was available. Outlets 1-4 are
// USB-C, 5-16 AC, 17-20 larger AC. Port 21 is management, the one port UniFi reports.
// Ports 22 and 23 are a surge pass-through pair (for a modem line) with no data.
USPPDUP: {
width: 1174, height: 215, frameClass: 'fp-scroll', noBody: true,
label: 'USP PDU Pro',
legend: [['outlet-on', 'outlet on'], ['outlet-off', 'outlet off'], ['cycle', 'auto power-cycle']],
roles: { 21: 'RJ45 management' },
ports: [
{ idx: 21, anyPort: true, type: 'rj45', x: 996.5, y: 178, label: [996.5, 200] },
],
outlets: [
...[[1, 74, 22, [68, 36]], [2, 74, 62, [68, 76]], [3, 109, 22, [102, 36]], [4, 109, 62, [102, 76]]]
.map(([idx, x, y, label]) => ({ idx, kind: 'usbc', x, y, w: 9, h: 24, label })),
...Array.from({ length: 12 }, (_, i) => {
const x = 175 + i * 66.75;
return { idx: 5 + i, kind: 'horizontal', x, y: 21, w: 66, h: 64, label: [x + 33, 96] };
}),
...[208, 431, 654, 877].map((x, i) => ({
idx: 17 + i, kind: i === 3 ? 'vertical-20' : 'vertical', x, y: 126, w: 66, h: 67, label: [x + 33, 205],
})),
],
decor() {
const ear = x => `<rect class="fp-ear" x="${x}" y="2" width="48" height="211" rx="5"/>
<rect class="fp-ear-hole" x="${x + 13}" y="7" width="27" height="17" rx="8.5"/>
<rect class="fp-ear-hole" x="${x + 13}" y="189" width="27" height="17" rx="8.5"/>`;
return `${ear(0)}${ear(1126)}
<rect class="fp-body-metal" x="48" y="1" width="1078" height="213" rx="1"/>
${fpQuadScreen(61, 132, 56)}${fpModel(89, 199, 'USP', 'PDU Pro')}
<circle class="fp-button" cx="1053" cy="53" r="4.5"/>
<rect class="fp-block" x="977" y="160" width="39" height="32.5" rx="1"/>
<rect class="fp-block" x="1032" y="130" width="41" height="62.5" rx="1"/>
${fpPassiveJack(1052.5, 147, false, 'Port 22 · surge pass-through · not monitored')}
${fpPassiveJack(1052.5, 175.5, true, 'Port 23 · surge pass-through · not monitored')}
<text class="fp-label" x="1049" y="127" text-anchor="middle">22</text>${fpGlobe(1059, 124)}
<text class="fp-label" x="1049" y="205" text-anchor="middle">23</text>${fpGlobe(1059, 202)}
${fpReset(1088, 201)}`;
},
},
// Front and rear from the labeled diagrams on Ubiquiti's store page:
// https://store.ui.com/us/en/products/ups-2u-pro
// The outlets are on the rear, and the touchscreen shows a tile for each one.
USPDA2B: {
width: 1086, height: 460, frameClass: 'fp-scroll fp-stack', scrollX: 340, noBody: true,
rackView: [0, 0, 1086, 210], // the front only, for the rack drawing
label: 'UPS 2U Pro',
legend: [['outlet-on', 'outlet on'], ['outlet-off', 'outlet off'], ['blue', 'online']],
ports: [],
outlets: [
...[457, 478, 498, 535].flatMap((x, i) => [
{ idx: i + 1, kind: 'tile', x, y: 83, w: 18, h: 18 },
{ idx: i + 5, kind: 'tile', x, y: 104, w: 18, h: 18 },
]),
...[173, 251, 330, 479].flatMap((x, i) => [
{ idx: i + 1, kind: 'vertical-20', flip: true, x, y: 270, w: 66, h: 66, label: [x + 33, 350] },
{ idx: i + 5, kind: 'vertical-20', x, y: 373, w: 66, h: 66, label: [x + 33, 453] },
]),
],
decor({ online }) {
const spans = [[52, 238], [251, 437], [449, 636], [647, 834], [846, 1032]];
const vents = y => spans.flatMap(([a, b]) => [
`<rect class="fp-ups-vent" x="${a}" y="${y}" width="${b - a}" height="12" rx="5"/>`,
`<path class="fp-ups-rib" d="M${a + (b - a) / 3} ${y} v12 M${a + 2 * (b - a) / 3} ${y} v12"/>`,
]).join('');
return `<rect class="fp-body-metal" width="1086" height="210" rx="3"/>
<rect class="fp-ups-band-light" x="28" y="4" width="1030" height="24" rx="10"/>${vents(10)}
<rect class="fp-ups-band" x="28" y="183" width="1030" height="24" rx="10"/>${vents(188)}
<circle class="fp-power-ring ${online ? 'fp-power-on' : ''}" cx="51" cy="105" r="19"/>
<circle class="fp-power-face" cx="51" cy="105" r="15"/>
<path class="fp-power-icon" d="M46.5 100.5 a6.5 6.5 0 1 0 9 0 M51 97 v8"/>
<rect class="fp-ups-batt" x="80" y="100" width="15" height="10" rx="2.5"/>
<rect class="fp-ups-batt-tip" x="95.5" y="103" width="1.5" height="4"/>
<text class="fp-label" x="100" y="109">UPS Pro</text>
<rect class="fp-screen" x="430" y="77" width="224" height="55" rx="3"/>
<rect class="fp-screen-tile-dim" x="586" y="83" width="16" height="14" rx="2"/>
<rect class="fp-screen-tile-dim" x="606" y="83" width="16" height="14" rx="2"/>
<rect class="fp-screen-tile-dim" x="596" y="104" width="16" height="14" rx="2"/>
<circle class="fp-screen-icon" cx="643" cy="105" r="3.5"/>
<text class="fp-caption" x="0" y="238">REAR</text>
<g transform="translate(0 248)">
<rect class="fp-body-metal" width="1086" height="210" rx="3"/>
<circle class="fp-button" cx="68" cy="53" r="22"/><circle class="fp-breaker" cx="68" cy="53" r="11"/>
<text class="fp-label fp-label-sm" x="68" y="87" text-anchor="middle">BREAKER</text>
<circle class="fp-button" cx="68" cy="155" r="25"/><circle class="fp-breaker" cx="68" cy="155" r="13"/>
<text class="fp-label fp-label-sm" x="68" y="192" text-anchor="middle">POWER INPUT</text>
<path class="fp-fan" d="M721 20 a83 83 0 1 0 0.01 0 Z M721 52 a51 51 0 1 0 0.01 0 Z"/>
<path class="fp-fan-strut" d="M721 20 v32 M638 103 h32 M804 103 h-32 M721 186 v-32"/>
<rect class="fp-epo" x="893" y="80" width="15" height="45" rx="1"/>
<text class="fp-label fp-label-sm" x="900.5" y="74" text-anchor="middle">EPO</text>
<path class="fp-bracket" d="M955 88 v-8 h96 v8"/>
<text class="fp-label fp-label-sm" x="1003" y="74" text-anchor="middle">SURGE NETWORK</text>
<text class="fp-label fp-label-sm" x="973" y="134" text-anchor="middle">IN</text>
<text class="fp-label fp-label-sm" x="1033" y="134" text-anchor="middle">OUT</text>
${fpPassiveJack(973, 110, false, 'Surge in · not monitored')}
${fpPassiveJack(1033, 110, false, 'Surge out · not monitored')}
<rect class="fp-block" x="953" y="145" width="40" height="34" rx="1"/>
${fpPassiveJack(973, 165, false, 'MGMT · 100/10 MbE · not monitored per port')}
<text class="fp-label fp-label-sm" x="973" y="192" text-anchor="middle">MGMT</text>
</g>`;
},
},
};
function faceplateLegendSwatch(cls) {
if (cls === 'poe') return '<svg class="fp-legend-icon" viewBox="0 0 6 10"><path class="fp-bolt" d="M3 0 L0 5 H2.2 L1.4 9 L5 3.6 H2.8 L4 0 Z"/></svg>';
if (cls === 'cycle') return '<svg class="fp-legend-icon" viewBox="0 0 10 10"><path class="fp-cycle" d="M7 1.5 A3.5 3.5 0 1 0 8 5 M7 0 V2.5 H4.5"/></svg>';
return `<span class="fp-legend-led fp-led-${cls}"></span>`;
}
const CUTSHEET_MARK_LEGEND = [['ok', 'Matches cutsheet'], ['bad', 'Cutsheet mismatch'], ['doc', 'Documented, unconfirmed']];
function faceplateLegendHtml(spec, marks) {
let items = spec.legend.map(([cls, text]) =>
`<div class="chassis-legend-item">${faceplateLegendSwatch(cls)}${text}</div>`).join('');
if (marks && marks.size) {
items += CUTSHEET_MARK_LEGEND.filter(([m]) => marks.has(m)).map(([m, text]) =>
`<div class="chassis-legend-item fp-mark-key"><svg class="fp-legend-icon" viewBox="0 0 8 8"><circle class="fp-mark fp-mark-${m}" cx="4" cy="4" r="3.2"/></svg>${text}</div>`).join('');
items += `<label class="chassis-legend-item fp-mark-toggle"><input type="checkbox" data-action="toggle-cutsheet-marks"
${document.body.classList.contains('fp-marks-off') ? '' : 'checked'}> Cutsheet marks</label>`;
}
const hasDetail = spec.ports.length || spec.outlets;
return `<div class="chassis-legend">
${items}
${hasDetail ? '<div class="chassis-legend-item fp-readout" id="fp-readout" aria-live="polite"></div>' : ''}
</div>`;
}
// ctx: { swName, portMap, outlets, online, titleFor(port, idx, role), cutsheetFor?(idx) -> {mark, text},
// rack? (draw only the front, spec.rackView, as mounted in a rack) }
function renderFaceplate(model, ctx) {
const spec = FACEPLATES[model];
const anyPort = Object.values(ctx.portMap)[0];
const marks = new Set();
const ports = spec.ports.map(p => {
const port = ctx.portMap[p.idx] || (p.anyPort ? anyPort : undefined);
let title = ctx.titleFor(port, p.idx, spec.roles && spec.roles[p.idx]);
const cs = ctx.cutsheetFor ? ctx.cutsheetFor((p.anyPort && port) ? port.port_idx : p.idx) : null;
if (cs) {
marks.add(cs.mark);
title += lt.escHtml(` · ${cs.text}`);
}
return faceplatePortSvg(p, port, ctx.swName, title, cs && cs.mark);
}).join('');
const outletData = Object.fromEntries((ctx.outlets || []).map(o => [o.index, o]));
const outlets = (spec.outlets || []).map(o => faceplateOutletSvg(o, outletData[o.idx])).join('');
const body = spec.noBody ? ''
: `<rect class="fp-body" width="${spec.width}" height="${spec.height}" rx="3"/>`;
return `<div class="fp-wrap">
<div class="fp-frame ${spec.frameClass}">
<svg class="fp-svg" viewBox="${((ctx.rack && spec.rackView) || [0, 0, spec.width, spec.height]).join(' ')}" role="group" aria-label="${lt.escHtml(spec.label)} front panel">
<defs>
<linearGradient id="fp-metal" x1="0" y1="0" x2="0" y2="1">
<stop offset="0" stop-color="#e4e4e6"/><stop offset=".08" stop-color="#d6d6d8"/>
<stop offset=".92" stop-color="#cfcfd2"/><stop offset="1" stop-color="#a9a9ad"/>
</linearGradient>
<linearGradient id="fp-bay-face" x1="0" y1="0" x2="0" y2="1">
<stop offset="0" stop-color="#d9d9db"/><stop offset="1" stop-color="#cdcdd0"/>
</linearGradient>
</defs>
${body}
${spec.decor({ online: ctx.online })}
${outlets}
${ports}
</svg>
</div>
</div>${faceplateLegendHtml(spec, marks)}`;
}
// Where an fp-scroll panel should start: its port area
function faceplateScrollLeft(model, frame) {
const spec = FACEPLATES[model];
return spec.scrollX ? (frame.scrollWidth / spec.width) * spec.scrollX : 0;
}
+148
View File
@@ -0,0 +1,148 @@
'use strict';
/* exported RACK_FRONTS, CHASSIS_FACEPLATES, rackFrontSvg */
// Drawn fronts for rack gear Gandalf can't read a faceplate from: custom-built servers. Chosen per cutsheet item ("Front drawing"). Each one
// shows the device's live status on its power light when the item is linked to a device.
//
// Spec: { label, units, width, height, draw(ctx) -> SVG markup }, ctx: { status, name }.
// Width:height should be about 10.5:1 per rack unit so the drawing fills its slot.
const FRONT_STATUS = { up: '#2fd36b', degraded: '#ffb300', down: '#e0312b' };
function frontLed(status) {
return FRONT_STATUS[status] || '#6b737d';
}
function ears(w, h, cls = 'rf-ear') {
// Rack ears with their mounting slots, both sides
const slots = Array.from({ length: Math.round(h / 105) }, (_, i) => 105 * i + 52);
const holes = x => slots.map(y => `<rect class="rf-slot" x="${x}" y="${y - 9}" width="9" height="18" rx="4"/>`).join('');
return `<rect class="${cls}" x="0" y="0" width="34" height="${h}" rx="3"/>${holes(12)}
<rect class="${cls}" x="${w - 34}" y="0" width="34" height="${h}" rx="3"/>${holes(w - 21)}`;
}
function vents(x0, x1, y, h = 8, gap = 6, seg = 120) {
const out = [];
for (let x = x0; x + seg <= x1; x += seg + gap) out.push(`<rect class="rf-vent" x="${x}" y="${y}" width="${seg}" height="${h}" rx="${h / 2}"/>`);
return out.join('');
}
function powerButton(cx, cy, r, status) {
return `<circle class="rf-power-ring" cx="${cx}" cy="${cy}" r="${r}" style="stroke:${frontLed(status)}"/>
<path class="rf-power-icon" d="M${cx - r * 0.35} ${cy - r * 0.3} a${r * 0.48} ${r * 0.48} 0 1 0 ${r * 0.7} 0 M${cx} ${cy - r * 0.55} v${r * 0.5}"/>`;
}
function usbA(x, y) {
return `<rect class="rf-port" x="${x}" y="${y}" width="22" height="9" rx="1"/><rect class="rf-port-tongue" x="${x + 3}" y="${y + 2}" width="16" height="3"/>`;
}
function usbC(x, y) {
return `<rect class="rf-port" x="${x}" y="${y}" width="16" height="6" rx="3"/>`;
}
function keyLock(cx, cy) {
return `<circle class="rf-lock" cx="${cx}" cy="${cy}" r="9"/><rect class="rf-lock-slot" x="${cx - 1.5}" y="${cy - 6}" width="3" height="12" rx="1"/>`;
}
function brand(x, y, text, anchor = 'start') {
return `<text class="rf-brand" x="${x}" y="${y}" text-anchor="${anchor}">${text}</text>`;
}
function driveBay(x, y, w, h, vertical) {
// A hot-swap bay: tray face, latch and activity light
const latch = vertical
? `<rect class="rf-latch" x="${x + w / 2 - 6}" y="${y + h - 26}" width="12" height="18" rx="2"/>`
: `<rect class="rf-latch" x="${x + w - 26}" y="${y + h / 2 - 6}" width="18" height="12" rx="2"/>`;
const led = vertical ? `<circle class="rf-bay-led" cx="${x + w / 2}" cy="${y + 10}" r="2.5"/>`
: `<circle class="rf-bay-led" cx="${x + 10}" cy="${y + h / 2}" r="2.5"/>`;
return `<rect class="rf-bay" x="${x}" y="${y}" width="${w}" height="${h}" rx="3"/>${latch}${led}`;
}
const RACK_FRONTS = {
// Sliger CX4712 4U with its faceplate off (as driveAtlas draws it): two 5.25" blanks side by
// side, ten 3.5" hot-swap bays standing on edge in one row, a narrow I/O strip on the right.
'sliger-cx4712': {
label: 'Sliger CX4712 4U (10-bay)', units: 4, width: 1100, height: 420,
draw({ status }) {
// Bays numbered left to right, the local convention driveAtlas uses for this case
const bays = Array.from({ length: 10 }, (_, i) => `${driveBay(78 + i * 86, 150, 78, 228, true)}
<text class="rf-bay-num" x="${117 + i * 86}" y="396" text-anchor="middle">${i + 1}</text>`).join('');
return `<rect class="rf-body-dark" width="1100" height="420" rx="3"/>${ears(1100, 420, 'rf-ear-dark')}
<rect class="rf-blank" x="78" y="30" width="418" height="98" rx="3"/>
<rect class="rf-blank" x="510" y="30" width="418" height="98" rx="3"/>
${vents(98, 480, 74, 7, 8, 40)}${vents(530, 912, 74, 7, 8, 40)}
${bays}
<rect class="rf-io" x="950" y="30" width="104" height="360" rx="4"/>
${powerButton(1002, 78, 20, status)}
${usbA(991, 130)}${usbA(991, 150)}${usbC(995, 176)}
${keyLock(1002, 220)}
${brand(1002, 372, 'SLIGER', 'middle')}`;
},
},
// Rosewill RSV-L4500U 4U: the perforated, lockable drop-down door over the fan wall
// (15 bays sit behind it), D-handles on the ears, I/O strip with power and USB on the right.
'rosewill-rsv-l4500u': {
label: 'Rosewill RSV-L4500U 4U (15-bay)', units: 4, width: 1100, height: 420,
draw({ status }) {
const fan = cx => `<circle class="rf-fan" cx="${cx}" cy="210" r="112"/>
<circle class="rf-fan-hub" cx="${cx}" cy="210" r="30"/>
${[0, 72, 144, 216, 288].map(a => `<path class="rf-fan-blade" transform="rotate(${a} ${cx} 210)" d="M${cx} 180 q40 -40 70 -10 q-30 10 -70 40 z"/>`).join('')}`;
const handle = x => `<rect class="rf-handle" x="${x}" y="60" width="16" height="300" rx="8"/>`;
return `<rect class="rf-body-dark" width="1100" height="420" rx="3"/>${ears(1100, 420, 'rf-ear-dark')}
${handle(36)}${handle(1048)}
<defs><pattern id="rf-perf" width="9" height="9" patternUnits="userSpaceOnUse">
<circle class="rf-perf-hole" cx="4.5" cy="4.5" r="2.4"/></pattern></defs>
<rect class="rf-door" x="64" y="16" width="880" height="388" rx="6"/>
${fan(225)}${fan(504)}${fan(783)}
<rect class="rf-mesh" x="80" y="32" width="848" height="356" rx="4" fill="url(#rf-perf)"/>
<rect class="rf-door-latch" x="900" y="180" width="26" height="60" rx="5"/>
<rect class="rf-io" x="954" y="16" width="86" height="388" rx="4"/>
${powerButton(997, 62, 18, status)}
<circle class="rf-reset" cx="997" cy="104" r="5"/>
<circle class="rf-led" cx="985" cy="130" r="3.5" style="fill:${frontLed(status)}"/><circle class="rf-led" cx="1009" cy="130" r="3.5"/>
${usbA(986, 160)}${usbA(986, 180)}
${keyLock(997, 232)}
${brand(997, 388, 'ROSEWILL', 'middle')}`;
},
},
// Generic servers, for gear without a specific drawing
'server-1u': genericServer(1, 4),
'server-2u': genericServer(2, 12),
'server-4u': genericServer(4, 24),
};
function genericServer(units, bays) {
const H = 105 * units;
return {
label: `Generic ${units}U server`, units, width: 1100, height: H,
draw({ status }) {
const rows = Math.max(1, Math.round(units * 0.75));
const cols = Math.ceil(bays / rows);
const bw = Math.min(118, 720 / cols - 8);
const bh = (H - 30 - (rows - 1) * 8) / rows;
const out = [];
for (let r = 0; r < rows; r++) {
for (let c = 0; c < cols && r * cols + c < bays; c++) out.push(driveBay(60 + c * (bw + 8), 15 + r * (bh + 8), bw, bh, false));
}
return `<rect class="rf-body-dark" width="1100" height="${H}" rx="3"/>${ears(1100, H, 'rf-ear-dark')}
${out.join('')}
${vents(810, 1040, 18, 7, 6, 36)}${units > 1 ? vents(810, 1040, H - 26, 7, 6, 36) : ''}
${powerButton(1020, H / 2, Math.min(18, H / 5), status)}`;
},
};
}
// Front drawings that are full faceplates in faceplates.js (same parts as the UniFi gear)
const CHASSIS_FACEPLATES = { 'unvr-pro': 'UNVRPRO' };
// The markup for one item's drawn front, or '' when the key is unknown
function rackFrontSvg(key, ctx) {
const spec = RACK_FRONTS[key];
if (!spec) return '';
return `<svg class="rack-svg rack-front" viewBox="0 0 ${spec.width} ${spec.height}" preserveAspectRatio="none"
role="img" aria-label="${lt.escHtml(`${ctx.name}: ${spec.label}${ctx.status ? `, ${ctx.status}` : ''}`)}">
<title>${lt.escHtml(`${ctx.name} · ${spec.label}${ctx.status ? ` · ${ctx.status}` : ''}`)}</title>
${spec.draw(ctx)}
</svg>`;
}
+199 -117
View File
@@ -1,5 +1,5 @@
'use strict';
/* global deviceUrl */
/* global deviceUrl, FACEPLATES, renderFaceplate, faceplateScrollLeft */
/* exported renderPortInspector, fmtRate, fmtErrors */
// Port inspector for a switch or router's device page: front-panel diagram,
@@ -7,35 +7,15 @@
const escHtml = s => lt.escHtml(s);
// ── Switch layout config ─────────────────────────────────────────────────
// keys match the model field returned by the UniFi API
// rows: array of rows, each row is an array of port_idx values
// sfp_ports: port_idx values that are SFP cages (in rows, rendered differently)
// sfp_section: port_idx values rendered as a separate SFP bank below the rows
const SWITCH_LAYOUTS = {
'USF5P': { rows: [[1,2,3,4]], sfp_section: [5] },
'USL8A': { rows: [[1,2,3,4],[5,6,7,8]], sfp_ports: [1,2,3,4,5,6,7,8] },
'US24PRO': {
rows: [
[1,3,5,7,9,11,13,15,17,19,21,23],
[2,4,6,8,10,12,14,16,18,20,22,24],
],
sfp_section: [25,26],
},
'USPPDUP': { rows: [[1]] },
'USMINI': { rows: [[1,2,3,4,5]] },
'UDMPRO': { rows: [[1,2,3,4,5,6,7,8,9]], sfp_section: [10,11] },
};
// ── Formatting helpers ───────────────────────────────────────────────────
function fmtShortSpeed(mbps) {
if (!mbps) return '–';
if (!mbps) return '-';
if (mbps >= 1000) return (mbps / 1000).toFixed(0) + 'G';
return mbps + 'M';
}
function fmtRate(bytesPerSec) {
if (bytesPerSec === null || bytesPerSec === undefined) return '–';
if (bytesPerSec === null || bytesPerSec === undefined) return '-';
const bps = bytesPerSec * 8;
if (bps < 1e3) return bps.toFixed(0) + ' bps';
if (bps < 1e6) return (bps / 1e3).toFixed(1) + ' Kbps';
@@ -44,7 +24,7 @@ function fmtRate(bytesPerSec) {
}
function fmtErrors(rate) {
if (rate === null || rate === undefined) return '–';
if (rate === null || rate === undefined) return '-';
if (rate < 0.001) return '<span class="val-good">0 /s</span>';
return `<span class="val-crit">${rate.toFixed(3)} /s</span>`;
}
@@ -86,6 +66,125 @@ function portTitle(port, idx) {
return escHtml(neighbor ? `${port.name} → ${neighbor}` : port.name);
}
function sfpKindLabel(sfp) {
if (sfp.kind === 'dac') return 'DAC';
if (sfp.kind === 'optic') return sfp.compliance || 'Optic';
return 'Module';
}
function faceplatePortTitle(port, idx, role) {
const parts = [role ? `Port ${idx} (${role})` : `Port ${idx}`];
const sfp = port && port.sfp;
if (!port || !port.up) {
parts.push(sfp && !sfp.found ? 'empty cage' : 'no link');
} else {
const speed = portSpeedLabel(port);
if (speed) parts.push(speed);
if (port.poe_power > 0) parts.push(`${port.poe_power.toFixed(1)} W PoE`);
}
if (sfp && sfp.found) parts.push(sfp.part ? `${sfpKindLabel(sfp)} ${sfp.part}` : sfpKindLabel(sfp));
if (sfp && (sfp.rx_fault || sfp.tx_fault)) parts.push('module fault');
const neighbor = port && port.lldp && (port.lldp.system_name || port.lldp.chassis_id);
if (neighbor) parts.push(`→ ${neighbor}`);
return escHtml(parts.join(' · '));
}
// ── Cutsheet section of the port panel ──────────────────────────────────
const CUTSHEET_PROBLEM = new Set(['wrong_neighbor', 'no_link', 'missing_port', 'conflict']);
function cutsheetPanelHtml(swName, idx) {
const entries = ((_apiData && _apiData.cutsheet) || []).filter(e => e.port === String(idx));
const head = '<div class="lt-divider"><span class="lt-divider-label">Cutsheet</span></div>';
if (!entries.length) {
const add = `/cutsheet?a_device=${encodeURIComponent(swName)}&a_port=${encodeURIComponent(idx)}`;
return `${head}<div class="panel-row"><span class="panel-label">Planned</span><span class="panel-val">
<span class="val-neutral">Not documented</span> · <a class="device-link" href="${escHtml(add)}">Add cable</a></span></div>`;
}
return head + entries.map(e => {
const cls = CUTSHEET_PROBLEM.has(e.verdict) ? 'val-crit' : (e.verdict === 'match' ? 'val-good' : 'val-neutral');
const path = (e.path || []).filter(h => !('cable_id' in h)).map(h => escHtml(h.text)).join(' → ');
const name = e.label ? escHtml(e.label) : 'unlabeled';
return `
<div class="panel-row"><span class="panel-label">Cable</span><span class="panel-val">
<a class="device-link" href="/cutsheet#cable-${encodeURIComponent(e.id)}">${name}</a> · ${escHtml(e.status)}</span></div>
<div class="cutsheet-check ${cls}">${escHtml(e.detail)}</div>
${path ? `<div class="cutsheet-path">${path}</div>` : ''}`;
}).join('');
}
// The faceplate dot for one port: the worst state of the cables documented on it
const MARK_RANK = { bad: 3, doc: 2, ok: 1 };
function cutsheetMarkFor(idx) {
const entries = ((_apiData && _apiData.cutsheet) || []).filter(e => e.port === String(idx) && e.status !== 'retired');
if (!entries.length) return null;
let best = null;
entries.forEach(e => {
const mark = CUTSHEET_PROBLEM.has(e.verdict) ? 'bad' : (e.verdict === 'match' ? 'ok' : 'doc');
if (!best || MARK_RANK[mark] > MARK_RANK[best.mark]) {
best = { mark, text: `cable ${e.label || 'unlabeled'}: ${e.detail}` };
}
});
return best;
}
document.addEventListener('change', e => {
if (!e.target.matches('[data-action="toggle-cutsheet-marks"]')) return;
const off = !e.target.checked;
document.body.classList.toggle('fp-marks-off', off);
try { localStorage.setItem('gandalf.cutsheetMarks', off ? 'off' : 'on'); } catch (_) { /* private mode */ }
});
try {
if (localStorage.getItem('gandalf.cutsheetMarks') === 'off') document.body.classList.add('fp-marks-off');
} catch (_) { /* private mode */ }
// ── SFP module section of the port panel ────────────────────────────────
function sfpPanelHtml(sfp) {
if (!sfp) return '';
const row = (label, val, tip) =>
`<div class="panel-row"><span class="panel-label"${tip ? ` data-tooltip="${escHtml(tip)}"` : ''}>${label}</span><span class="panel-val">${val}</span></div>`;
const head = '<div class="lt-divider"><span class="lt-divider-label">SFP Module</span></div>';
if (!sfp.found) return head + row('Module', '<span class="val-neutral">Empty cage</span>');
const rows = [row('Type', escHtml(sfpKindLabel(sfp)))];
const model = [sfp.vendor, sfp.part].filter(Boolean).join(' ');
if (model) rows.push(row('Part', escHtml(model)));
if (sfp.serial) rows.push(row('Serial', escHtml(sfp.serial)));
if (sfp.rx_fault || sfp.tx_fault) {
const which = [sfp.rx_fault && 'receive', sfp.tx_fault && 'transmit'].filter(Boolean).join(' and ');
rows.push(row('Fault', `<span class="val-crit">${which} fault</span>`, 'Flags the module itself raises: receive = loss of signal, transmit = laser fault.'));
}
if (sfp.rx_power_dbm != null) {
rows.push(row('RX power', `${sfp.rx_power_dbm.toFixed(2)} dBm ${renderPowerBar(sfp.rx_power_dbm, -18, -25)}`, 'Light received from the far end'));
}
if (sfp.tx_power_dbm != null) {
rows.push(row('TX power', `${sfp.tx_power_dbm.toFixed(2)} dBm ${renderPowerBar(sfp.tx_power_dbm, -10, -13)}`, 'Light this module sends'));
}
if (sfp.temperature_c != null) rows.push(row('Temp', `${sfp.temperature_c.toFixed(1)} °C`));
if (sfp.voltage_v != null) rows.push(row('Voltage', `${sfp.voltage_v.toFixed(2)} V`));
if (sfp.current_ma != null) rows.push(row('Bias', `${sfp.current_ma.toFixed(1)} mA`, 'Laser bias current'));
if (sfp.kind === 'dac' && sfp.rx_power_dbm == null) {
rows.push(row('Readings', '<span class="val-neutral">None: copper DACs have no optics</span>'));
}
const peer = sfp.cable_peer;
if (peer) {
const href = `${deviceUrl(peer.switch)}#port-${encodeURIComponent(peer.port_idx)}`;
rows.push(row('Other end', `<a class="device-link" href="${escHtml(href)}">${escHtml(peer.switch)} port ${escHtml(String(peer.port_idx))}</a>`,
'Both ends of this DAC report the same cable serial'));
}
return head + rows.join('');
}
// Faceplate jacks are too small for text, so one line under the panel names
// the hovered or selected port.
function updateFaceplateReadout(el) {
const readout = document.getElementById('fp-readout');
if (!readout) return;
const target = el || document.querySelector('.fp-port.selected');
const title = target && target.getAttribute('aria-label');
readout.textContent = title || (document.querySelector('.fp-outlet') ? 'Hover or select an outlet or port' : 'Hover or select a port');
}
// ── Render a single port block element ──────────────────────────────────
function portBlockHtml(idx, port, swName, sfpBlock) {
const state = portBlockState(port);
@@ -118,78 +217,37 @@ function chassisLegendHtml() {
// ── Render one switch chassis ────────────────────────────────────────────
function renderChassis(swName, sw) {
const model = sw.model || '';
const layout = SWITCH_LAYOUTS[model] || null;
const portMap = buildPortIdxMap(sw.ports || {});
const ports = Object.entries(sw.ports || {});
const upCount = Object.values(sw.ports || {}).filter(p => p.up).length;
const totCount = Object.keys(sw.ports || {}).length;
const downCount = totCount - upCount;
const meta = [model, `${upCount}/${totCount} up`, downCount ? `${downCount} down` : ''].filter(Boolean).join(' · ');
// Is this a US24PRO? Used to add group-separator class
const isUs24Pro = (model === 'US24PRO');
let chassisHtml = '';
if (layout) {
const sfpPortSet = new Set(layout.sfp_ports || []);
const sfpSectionSet = new Set(layout.sfp_section || []);
// Main port rows
chassisHtml += '<div class="chassis-rows">';
for (const row of layout.rows) {
const rowCls = isUs24Pro ? ' us24pro-row' : '';
chassisHtml += `<div class="chassis-row${rowCls}">`;
for (const idx of row) {
const port = portMap[idx];
const isSfp = sfpPortSet.has(idx);
const sfpCls = isSfp ? ' sfp-port' : '';
const state = portBlockState(port);
const title = portTitle(port, idx);
const speedTxt = portSpeedLabel(port);
const lldpName = (port && port.lldp && (port.lldp.system_name || port.lldp.chassis_id))
? escHtml((port.lldp.system_name || port.lldp.chassis_id || '').slice(0, 6))
: '';
const speedHtml = speedTxt ? `<span class="port-speed">${speedTxt}</span>` : '';
const lldpHtml = lldpName ? `<span class="port-lldp">${lldpName}</span>` : '';
chassisHtml += `<div class="switch-port-block ${state}${sfpCls}"
data-switch="${escHtml(swName)}" data-port-idx="${idx}"
title="${title}" aria-label="${title}"
data-action="select-port" role="button" tabindex="0"><span class="port-num">${idx}</span>${speedHtml}${lldpHtml}</div>`;
}
chassisHtml += '</div>';
}
chassisHtml += '</div>';
// Separate SFP section (if present)
if (sfpSectionSet.size) {
chassisHtml += '<div class="chassis-sfp-section">';
for (const idx of layout.sfp_section) {
chassisHtml += portBlockHtml(idx, portMap[idx], swName, true);
}
chassisHtml += '</div>';
}
} else {
// Fallback: render all ports sorted by idx
const allPorts = Object.entries(sw.ports || {})
.sort(([, a], [, b]) => (a.port_idx || 0) - (b.port_idx || 0));
chassisHtml += '<div class="chassis-rows"><div class="chassis-row">';
for (const [pname, d] of allPorts) {
chassisHtml += portBlockHtml(d.port_idx || 0, Object.assign({ name: pname }, d), swName, false);
}
chassisHtml += '</div></div>';
}
return `
<div class="inspector-chassis">
<div class="chassis-header">
const upCount = ports.filter(([, p]) => p.up).length;
const downCount = ports.length - upCount;
const counts = ports.length ? [`${upCount}/${ports.length} up`, downCount ? `${downCount} down` : ''] : [];
const meta = [model, ...counts].filter(Boolean).join(' · ');
const header = `<div class="chassis-header">
<span class="chassis-name">Front panel</span>
<span class="chassis-meta">${escHtml(meta)}</span>
</div>
</div>`;
if (FACEPLATES[model]) {
return `<div class="inspector-chassis">${header}${renderFaceplate(model, {
swName, portMap, outlets: sw.outlets, online: sw.online, titleFor: faceplatePortTitle,
cutsheetFor: cutsheetMarkFor,
})}</div>`;
}
// No faceplate for this model yet: plain blocks in port order
const blocks = ports
.sort(([, a], [, b]) => (a.port_idx || 0) - (b.port_idx || 0))
.map(([pname, d]) => portBlockHtml(d.port_idx || 0, Object.assign({ name: pname }, d), swName, false))
.join('');
return `
<div class="inspector-chassis">
${header}
<div class="chassis-body">
<div class="chassis-ear-l"></div>
<div class="chassis-ear-r"></div>
${chassisHtml}
<div class="chassis-rows"><div class="chassis-row">${blocks}</div></div>
</div>
${chassisLegendHtml()}
</div>`;
@@ -240,11 +298,11 @@ function renderPanel(swName, idx) {
if (!d) return;
const upStr = d.up ? '<span class="val-good">UP</span>' : '<span class="val-crit">DOWN</span>';
const speedStr = d.speed_mbps ? `<span class="val-cyan">${fmtShortSpeed(d.speed_mbps)}bps</span>` : '–';
const speedStr = d.speed_mbps ? `<span class="val-cyan">${fmtShortSpeed(d.speed_mbps)}bps</span>` : '-';
const duplexCls = d.full_duplex ? 'val-good' : (d.up ? 'val-warn' : 'val-neutral');
const duplexStr = d.up ? `<span class="${duplexCls}">${d.full_duplex ? 'Full' : 'Half'}</span>` : '–';
const duplexStr = d.up ? `<span class="${duplexCls}">${d.full_duplex ? 'Full' : 'Half'}</span>` : '-';
const autoneg = d.autoneg ? 'On' : 'Off';
const mediaStr = d.media || '–';
const mediaStr = d.media || '-';
const isUplinkBadge = d.is_uplink ? ' <span class="port-badge port-badge-uplink">UPLINK</span>' : '';
// PoE section
@@ -263,8 +321,8 @@ function renderPanel(swName, idx) {
if (d.tx_bytes_rate != null || d.rx_bytes_rate != null) {
trafficHtml = `
<div class="lt-divider"><span class="lt-divider-label">Traffic</span></div>
<div class="panel-row"><span class="panel-label" data-tooltip="Transmit — outgoing from this port">TX</span><span class="panel-val">${fmtRate(d.tx_bytes_rate)}</span></div>
<div class="panel-row"><span class="panel-label" data-tooltip="Receive — incoming to this port">RX</span><span class="panel-val">${fmtRate(d.rx_bytes_rate)}</span></div>`;
<div class="panel-row"><span class="panel-label" data-tooltip="Transmit: outgoing from this port">TX</span><span class="panel-val">${fmtRate(d.tx_bytes_rate)}</span></div>
<div class="panel-row"><span class="panel-label" data-tooltip="Receive: incoming to this port">RX</span><span class="panel-val">${fmtRate(d.rx_bytes_rate)}</span></div>`;
}
// Errors / drops section
@@ -343,6 +401,8 @@ function renderPanel(swName, idx) {
<div class="panel-row"><span class="panel-label" data-tooltip="Autonegotiation: NIC and switch automatically agree speed and duplex.">Auto-neg</span><span class="panel-val val-neutral">${autoneg}</span></div>
<div class="panel-row"><span class="panel-label">Media</span><span class="panel-val">${escHtml(mediaStr)}</span></div>
${cutsheetPanelHtml(swName, idx)}
${sfpPanelHtml(d.sfp)}
${poeHtml}
${trafficHtml}
${errHtml}
@@ -387,14 +447,14 @@ function buildPathDebug(swName, swPort, serverName, ifaceName, svrData) {
const duplexMismatch = swPort.up && svrData.duplex &&
((swFull && !svrFull) || (!swFull && svrFull));
const duplexWarnHtml = duplexMismatch
? `<div class="path-mismatch-alert">⚠ DUPLEX MISMATCH — Switch: ${swFull ? 'Full' : 'Half'} · Server: ${escHtml(svrData.duplex)}</div>`
? `<div class="path-mismatch-alert">⚠ DUPLEX MISMATCH. Switch: ${swFull ? 'Full' : 'Half'} · Server: ${escHtml(svrData.duplex)}</div>`
: '';
// Detect speed mismatch
const swSpd = swPort.speed_mbps, svrSpd = svrData.speed_mbps;
const speedMismatch = swSpd && svrSpd && swSpd > 0 && svrSpd > 0 && swSpd !== svrSpd;
const speedWarnHtml = speedMismatch
? `<div class="path-mismatch-alert">⚠ SPEED MISMATCH — Switch: ${fmtShortSpeed(swSpd)} · Server: ${fmtShortSpeed(svrSpd)}</div>`
? `<div class="path-mismatch-alert">⚠ SPEED MISMATCH. Switch: ${fmtShortSpeed(swSpd)} · Server: ${fmtShortSpeed(svrSpd)}</div>`
: '';
return `
@@ -414,7 +474,7 @@ function buildPathDebug(swName, swPort, serverName, ifaceName, svrData) {
<div class="path-col">
<div class="path-col-header">Server: ${escHtml(serverName)}</div>
<div class="path-row"><span>Iface</span><span>${escHtml(ifaceName)}</span></div>
<div class="path-row"><span>Speed</span><span>${svrData.speed_mbps ? fmtShortSpeed(svrData.speed_mbps) + 'bps' : '–'}</span></div>
<div class="path-row"><span>Speed</span><span>${svrData.speed_mbps ? fmtShortSpeed(svrData.speed_mbps) + 'bps' : '-'}</span></div>
<div class="path-row"><span>TX</span><span>${fmtRate(svrData.tx_bytes_rate)}</span></div>
<div class="path-row"><span>RX</span><span>${fmtRate(svrData.rx_bytes_rate)}</span></div>
<div class="path-row"><span>TX Err</span><span class="${svrErrTx}">${fmtErrors(svrData.tx_errs_rate)}</span></div>
@@ -428,11 +488,20 @@ function buildPathDebug(swName, swPort, serverName, ifaceName, svrData) {
// ── Page integration: device.js supplies this one device's data ──────────
function renderPortInspector(detail) {
_apiData = {
unifi_switches: { [detail.name]: { ip: detail.ip, model: detail.model, ports: detail.ports || {} } },
unifi_switches: { [detail.name]: {
ip: detail.ip, model: detail.model, ports: detail.ports || {},
outlets: detail.info && detail.info.outlets, online: detail.status === 'up',
} },
hosts: detail.neighbor_hosts || {},
cutsheet: detail.cutsheet || [],
};
const chassis = document.getElementById('device-chassis');
// Auto-refresh redraws the panel, so keep a scrolled panel where the user left it
const oldFrame = chassis.querySelector('.fp-scroll');
const scrollLeft = oldFrame ? oldFrame.scrollLeft : null;
chassis.innerHTML = renderChassis(detail.name, _apiData.unifi_switches[detail.name]);
const frame = chassis.querySelector('.fp-scroll');
if (frame) frame.scrollLeft = scrollLeft !== null ? scrollLeft : faceplateScrollLeft(detail.model, frame);
if (_selectedSwitch === detail.name && _selectedIdx !== null) {
renderPanel(_selectedSwitch, _selectedIdx);
} else if (_selectedSwitch === null) {
@@ -447,9 +516,10 @@ function openPortFromHash(swName) {
}
function highlightSelectedPort() {
document.querySelectorAll('.switch-port-block').forEach(el => {
document.querySelectorAll('[data-action="select-port"]').forEach(el => {
el.classList.toggle('selected', parseInt(el.dataset.portIdx, 10) === _selectedIdx);
});
updateFaceplateReadout();
document.querySelectorAll('tr.device-row[data-port-idx]').forEach(row => {
row.classList.toggle('is-selected', parseInt(row.dataset.portIdx, 10) === _selectedIdx);
});
@@ -465,6 +535,18 @@ document.addEventListener('keydown', e => {
if (block) { e.preventDefault(); selectPort(block); }
});
document.addEventListener('mouseover', e => {
const port = e.target.closest && e.target.closest('.fp-port, .fp-outlet');
if (port) updateFaceplateReadout(port);
});
document.addEventListener('mouseout', e => {
if (e.target.closest && e.target.closest('.fp-port, .fp-outlet')) updateFaceplateReadout();
});
document.addEventListener('focusin', e => {
const port = e.target.closest && e.target.closest('.fp-port, .fp-outlet');
if (port) updateFaceplateReadout(port);
});
document.addEventListener('click', e => {
const portBlock = e.target.closest('[data-action="select-port"]');
if (portBlock) { selectPort(portBlock); return; }
@@ -505,7 +587,7 @@ function runDiagnostic(swName, portIdx) {
})
.catch(e => {
const msg = (e && e.status === 429)
? 'Rate limit reached — max 5 diagnostics per minute. Please wait.'
? 'Rate limit reached: max 5 diagnostics per minute. Please wait.'
: 'Error: ' + (e && e.message || 'Request failed');
statusEl.textContent = msg;
});
@@ -521,7 +603,7 @@ function pollDiagnostic(jobId, statusEl, resultsEl) {
statusEl.innerHTML = 'Timed out waiting for results. '
+ '<button class="lt-btn lt-btn-ghost lt-btn-sm" id="diag-retry-btn">Retry</button>';
document.getElementById('diag-retry-btn')?.addEventListener('click', () => {
const sel = document.querySelector('.switch-port-block.selected');
const sel = document.querySelector('[data-action="select-port"].selected');
if (sel) runDiagnostic(sel.dataset.switch, parseInt(sel.dataset.portIdx));
});
return;
@@ -541,7 +623,7 @@ function pollDiagnostic(jobId, statusEl, resultsEl) {
statusEl.innerHTML = 'Error: lost connection while collecting diagnostics. '
+ '<button class="lt-btn lt-btn-ghost lt-btn-sm" id="diag-retry-btn">Retry</button>';
document.getElementById('diag-retry-btn')?.addEventListener('click', () => {
const sel = document.querySelector('.switch-port-block.selected');
const sel = document.querySelector('[data-action="select-port"].selected');
if (sel) runDiagnostic(sel.dataset.switch, parseInt(sel.dataset.portIdx));
});
});
@@ -584,21 +666,21 @@ function renderDiagnosticResults(d, container) {
const issueRows = [...issues, ...warns, ...infoArr].map(item => {
const cls = issues.includes(item) ? 'diag-val-bad' : warns.includes(item) ? 'diag-val-warn' : 'diag-val-good';
const label = issues.includes(item) ? 'CRIT' : warns.includes(item) ? 'WARN' : 'INFO';
return `<div class="diag-issue-row"><span class="${cls}">[${label}]</span> <span class="diag-code">${escHtml(item.code)}</span> — ${escHtml(item.message)}</div>`;
return `<div class="diag-issue-row"><span class="${cls}">[${label}]</span> <span class="diag-code">${escHtml(item.code)}</span>: ${escHtml(item.message)}</div>`;
}).join('');
// ── Physical layer ──
const carrierVal = secs.carrier === '1' ? '<span class="diag-val-good">YES</span>' :
secs.carrier === '0' ? '<span class="diag-val-bad">NO</span>' : '–';
secs.carrier === '0' ? '<span class="diag-val-bad">NO</span>' : '-';
const operstateVal = (secs.operstate || '?').toUpperCase();
const opstateCls = secs.operstate === 'up' ? 'diag-val-good' : secs.operstate === 'down' ? 'diag-val-bad' : 'diag-val-warn';
const speedVal = eth.speed_mbps ? `<span class="diag-val-good">${fmtShortSpeed(eth.speed_mbps)}bps</span>` : '<span class="diag-val-warn">–</span>';
const speedVal = eth.speed_mbps ? `<span class="diag-val-good">${fmtShortSpeed(eth.speed_mbps)}bps</span>` : '<span class="diag-val-warn">-</span>';
const duplexVal = eth.duplex === 'full' ? '<span class="diag-val-good">Full</span>' :
eth.duplex === 'half' ? '<span class="diag-val-bad">Half</span>' : '–';
eth.duplex === 'half' ? '<span class="diag-val-bad">Half</span>' : '-';
const linkDetVal = eth.link_detected === true ? '<span class="diag-val-good">Yes</span>' :
eth.link_detected === false ? '<span class="diag-val-bad">No</span>' : '–';
eth.link_detected === false ? '<span class="diag-val-bad">No</span>' : '-';
const autonegVal = eth.auto_neg === true ? '<span class="diag-val-good">On</span>' :
eth.auto_neg === false ? '<span class="diag-val-warn">Off</span>' : '–';
eth.auto_neg === false ? '<span class="diag-val-warn">Off</span>' : '-';
const physHtml = `
<div class="diag-section">
@@ -687,8 +769,8 @@ function renderDiagnosticResults(d, container) {
<tr><td>RX Pause</td><td>${pause.rx_pause ? '<span class="diag-val-good">On</span>' : 'Off'}</td></tr>
<tr><td>TX Pause</td><td>${pause.tx_pause ? '<span class="diag-val-good">On</span>' : 'Off'}</td></tr>` : ''}
${hasRing ? `
<tr><td>RX Ring</td><td>${ring.rx_current != null ? ring.rx_current : '–'} / ${ring.rx_max != null ? ring.rx_max : '–'} max</td></tr>
<tr><td>TX Ring</td><td>${ring.tx_current != null ? ring.tx_current : '–'} / ${ring.tx_max != null ? ring.tx_max : '–'} max</td></tr>` : ''}
<tr><td>RX Ring</td><td>${ring.rx_current != null ? ring.rx_current : '-'} / ${ring.rx_max != null ? ring.rx_max : '-'} max</td></tr>
<tr><td>TX Ring</td><td>${ring.tx_current != null ? ring.tx_current : '-'} / ${ring.tx_max != null ? ring.tx_max : '-'} max</td></tr>` : ''}
</table>
</div>`;
}
@@ -717,15 +799,15 @@ function renderDiagnosticResults(d, container) {
<div class="path-debug-cols">
<div class="path-col">
<div class="path-col-header">Switch sees</div>
<div class="path-row"><span>System</span><span>${escHtml(swLldp.system_name || '–')}</span></div>
<div class="path-row"><span>Port</span><span>${escHtml(swLldp.port_id || '–')}</span></div>
<div class="path-row"><span>Chassis</span><span>${escHtml(swLldp.chassis_id || '–')}</span></div>
<div class="path-row"><span>System</span><span>${escHtml(swLldp.system_name || '-')}</span></div>
<div class="path-row"><span>Port</span><span>${escHtml(swLldp.port_id || '-')}</span></div>
<div class="path-row"><span>Chassis</span><span>${escHtml(swLldp.chassis_id || '-')}</span></div>
</div>
<div class="path-col">
<div class="path-col-header">Server lldpctl</div>
${lldpctl.available
? `<div class="path-row"><span>Neighbor</span><span>${escHtml(lldpctl.neighbor_system || '–')}</span></div>
<div class="path-row"><span>Port</span><span>${escHtml(lldpctl.neighbor_port || '–')}</span></div>`
? `<div class="path-row"><span>Neighbor</span><span>${escHtml(lldpctl.neighbor_system || '-')}</span></div>
<div class="path-row"><span>Port</span><span>${escHtml(lldpctl.neighbor_port || '-')}</span></div>`
: '<div class="path-row"><span class="diag-val-warn">lldpd not running</span></div>'}
</div>
</div>
@@ -756,8 +838,8 @@ function renderDiagnosticResults(d, container) {
<div class="diag-section-header">Switch Port Summary</div>
<table class="diag-table">
<tr><td>Status</td><td>${swPort.up ? '<span class="diag-val-good">UP</span>' : '<span class="diag-val-bad">DOWN</span>'}</td></tr>
<tr><td>Speed</td><td>${swPort.speed_mbps ? fmtShortSpeed(swPort.speed_mbps) + 'bps' : '–'}</td></tr>
<tr><td>Duplex</td><td>${swPort.full_duplex ? 'Full' : (swPort.up ? '<span class="diag-val-bad">Half</span>' : '–')}</td></tr>
<tr><td>Speed</td><td>${swPort.speed_mbps ? fmtShortSpeed(swPort.speed_mbps) + 'bps' : '-'}</td></tr>
<tr><td>Duplex</td><td>${swPort.full_duplex ? 'Full' : (swPort.up ? '<span class="diag-val-bad">Half</span>' : '-')}</td></tr>
<tr><td>TX Err</td><td>${fmtErrors(swPort.tx_errs_rate)}</td></tr>
<tr><td>RX Err</td><td>${fmtErrors(swPort.rx_errs_rate)}</td></tr>
${swPort.poe_power != null ? `<tr><td>PoE</td><td><span class="val-amber">${swPort.poe_power.toFixed(1)}W</span></td></tr>` : ''}
+586
View File
@@ -0,0 +1,586 @@
'use strict';
/* global FACEPLATES, renderFaceplate, RACK_CAN_EDIT, RACK_FRONTS, CHASSIS_FACEPLATES, rackFrontSvg */
// Rack page: draws the rack front from /api/rack. Switches use their real faceplates,
// patch panels a generic panel; hovering a port lights up every port on the same cable run.
const esc = s => lt.escHtml(s == null ? '' : String(s));
const RATIO = 10.5; // a 19" rack's width to one unit's height
const KIND_TEXT = { patch_panel: 'Patch panel', wall_jack: 'Wall jack', device: 'Device', shelf: 'Shelf', other: 'Other' };
let _rack = null;
function speedText(mbps) {
if (!mbps) return '';
return mbps >= 1000 ? `${mbps / 1000}G` : `${mbps}M`;
}
function portMapOf(ports) {
const map = {};
Object.entries(ports || {}).forEach(([name, p]) => {
if (p.port_idx != null) map[p.port_idx] = Object.assign({ name }, p);
});
return map;
}
function portTitle(port, idx) {
const parts = [port && port.name && port.name !== `Port ${idx}` ? `Port ${idx} "${port.name}"` : `Port ${idx}`];
if (port) {
parts.push(port.up ? (speedText(port.speed_mbps) || 'up') : 'down');
const nb = port.lldp && (port.lldp.system_name || port.lldp.chassis_id);
if (nb) parts.push(`→ ${nb}`);
}
return esc(parts.join(' · '));
}
function isRackFaceplate(model) {
const spec = FACEPLATES[model];
return !!spec && !/fp-desk/.test(spec.frameClass || '');
}
// ── Item drawings ───────────────────────────────────────────────────────
function switchHtml(item, model) {
// A live switch, or a faceplate picked by Front drawing (no port data: drawn unlinked)
const sw = item.switch || { model, ports: {}, outlets: [], online: item.status === 'up' };
return renderFaceplate(model || sw.model, {
swName: item.device, portMap: portMapOf(sw.ports), outlets: sw.outlets, online: sw.online, rack: true,
titleFor: (port, idx) => portTitle(port, idx),
cutsheetFor: idx => {
const m = item.ports[String(idx)];
return m ? { mark: m.mark, text: m.text } : null;
},
});
}
function panelSvg(item) {
const count = Math.max(1, item.port_count || 24);
const units = item.rack_height || 1;
const rows = Math.max(1, Math.min(units * 2, Math.ceil(count / 24)));
const perRow = Math.ceil(count / rows);
const W = 1100, H = 105 * units, ear = 70;
const pitch = Math.min(38, (W - ear * 2 - 40) / perRow);
const left = (W - pitch * perRow) / 2;
const rowH = (H - 20) / rows;
// Label characters that fit under one port at the label's font size (9px, ~5.6px a character)
const fit = Math.max(3, Math.floor((pitch - 2) / 5.6));
const short = (t, max = fit) => (t.length > max ? `${t.slice(0, max - 1)}…` : t);
const ports = [];
for (let n = 1; n <= count; n++) {
const r = Math.floor((n - 1) / perRow), c = (n - 1) % perRow;
const x = left + c * pitch + pitch / 2, y = 10 + r * rowH + rowH / 2;
const m = item.ports[String(n)];
const label = item.labels[String(n)] || '';
const title = [`Port ${n}`, label && `"${label}"`, m ? m.text : 'not on the cutsheet'].filter(Boolean).join(' · ');
const attrs = m ? ` data-run="${m.run.join(' ')}" data-cable="${m.cable_id}" tabindex="0" role="link"` : '';
ports.push(`<g class="rack-pp-port${m ? ` rack-pp-${m.mark}` : ''}"${attrs} transform="translate(${x} ${y})">
<title>${esc(title)}</title>
<text class="rack-pp-num" y="-17" text-anchor="middle">${n}</text>
<rect class="rack-pp-jack" x="-12" y="-10" width="24" height="20" rx="2"/>
<rect class="rack-pp-hit" x="${-pitch / 2}" y="-28" width="${pitch}" height="56"/>
${label ? `<text class="rack-pp-label" y="24" text-anchor="middle">${esc(short(label))}</text>` : ''}
</g>`);
}
return `<svg class="rack-svg" viewBox="0 0 ${W} ${H}" preserveAspectRatio="xMidYMid meet" role="group"
aria-label="${esc(item.name)} patch panel">
<rect class="rack-pp-body" width="${W}" height="${H}" rx="3"/>
<text class="rack-pp-name" x="14" y="17"><title>${esc(item.name)}</title>${esc(short(item.name, 48))}</text>
${ports.join('')}
</svg>`;
}
const STATUS_CLASS = { up: 'dot-up', down: 'dot-down', degraded: 'dot-degraded' };
function statusDot(status) {
return status ? `<span class="${STATUS_CLASS[status] || 'dot-unknown'}" title="${esc(status)}"></span>` : '';
}
function shelfHtml(item) {
const contents = item.contents || [];
const things = contents.map(c => `
<a class="rack-shelf-thing" href="${esc(c.url)}" title="${esc([c.name, c.model, c.status].filter(Boolean).join(' · '))}">
${statusDot(c.status)}<span class="rack-shelf-name">${esc(c.name)}</span>
</a>`).join('');
return `<div class="rack-plate rack-shelf">
<span class="rack-shelf-label">${esc(item.name)}</span>
<div class="rack-shelf-things">${things || '<span class="rack-plate-sub">empty shelf</span>'}</div>
</div>`;
}
// Ubiquiti UACC-Rack-Panel-Patch-Blank-24, laid out from the CC0 NetBox devicetype-library image
// (elevation-images/Ubiquiti/ubiquiti-uacc-rack-panel-patch-blank-24.front.png): a grey steel face,
// darker ears with oval holes, 24 square keystone openings in one row with the cable-support bar
// behind them, and a narrow cable slot at each end. A port with a documented cable gets a keystone jack.
function uaccPanelSvg(item) {
const W = 1178, H = 108, x0 = 107, pitch = 40.5, ow = 34, oy = 36, oh = 40;
const count = Math.min(item.port_count || 24, 24);
const ports = [];
for (let n = 1; n <= count; n++) {
const x = x0 + (n - 1) * pitch;
const m = item.ports[String(n)];
const label = item.labels[String(n)] || '';
const title = [`Port ${n}`, label && `"${label}"`, m ? m.text : 'not on the cutsheet'].filter(Boolean).join(' · ');
const attrs = m ? ` data-run="${m.run.join(' ')}" data-cable="${m.cable_id}" tabindex="0" role="link"` : '';
const jack = m ? `<rect class="ua-keystone" x="${x + 3}" y="${oy + 3}" width="${ow - 6}" height="${oh - 6}" rx="2"/>
<path class="ua-keystone-hole" d="M${x + 7} ${oy + 13} h20 v14 h-4 v4 h-12 v-4 h-4 z"/>` : '';
ports.push(`<g class="rack-pp-port ua-port${m ? ` rack-pp-${m.mark}` : ''}"${attrs}>
<title>${esc(title)}</title>
<rect class="ua-open" x="${x}" y="${oy}" width="${ow}" height="${oh}"/>
<rect class="ua-bar" x="${x}" y="${oy + 19}" width="${ow}" height="5"/>
${jack}
<rect class="rack-pp-jack ua-mark" x="${x - 1}" y="${oy - 1}" width="${ow + 2}" height="${oh + 2}" rx="1"/>
<text class="ua-num" x="${x + ow / 2}" y="${oy - 6}" text-anchor="middle">${n}</text>
${label ? `<text class="ua-label" x="${x + ow / 2}" y="${oy + oh + 12}" text-anchor="middle">${esc(label.length > 7 ? `${label.slice(0, 6)}…` : label)}</text>` : ''}
<rect class="rack-pp-hit" x="${x - 3}" y="${oy - 16}" width="${pitch}" height="${oh + 32}"/>
</g>`);
}
const hole = (x, y) => `<rect class="ua-hole" x="${x}" y="${y}" width="22" height="13" rx="6.5"/>`;
return `<svg class="rack-svg" viewBox="0 0 ${W} ${H}" preserveAspectRatio="none" role="group"
aria-label="${esc(item.name)} patch panel">
<title>${esc(item.name)}</title>
<rect class="ua-ear" x="0" y="2" width="44" height="${H - 4}" rx="3"/>
<rect class="ua-ear" x="${W - 44}" y="2" width="44" height="${H - 4}" rx="3"/>
${hole(8, 12)}${hole(8, 83)}${hole(W - 30, 12)}${hole(W - 30, 83)}
<rect class="ua-face" x="36" y="0" width="${W - 72}" height="${H}" rx="2"/>
<rect class="ua-lip" x="36" y="0" width="${W - 72}" height="4"/>
<rect class="ua-open" x="62" y="${oy}" width="28" height="${oh}"/><rect class="ua-bar" x="62" y="${oy + 19}" width="28" height="5"/>
<rect class="ua-open" x="${W - 95}" y="${oy}" width="28" height="${oh}"/><rect class="ua-bar" x="${W - 95}" y="${oy + 19}" width="28" height="5"/>
${ports.join('')}
</svg>`;
}
function plateHtml(item) {
const unlinked = item.kind === 'device' && !item.linked;
const sub = [item.device !== item.name ? item.device : '', KIND_TEXT[item.kind] || item.kind, item.location,
unlinked ? 'not linked to a Gandalf device' : ''].filter(Boolean).join(' · ');
return `<div class="rack-plate">
${statusDot(item.status)}<a class="device-link rack-plate-name" href="${esc(item.url)}">${esc(item.name)}</a>
<span class="rack-plate-sub">${esc(sub)}</span>
</div>`;
}
function backHtml(item) {
// A full-depth item seen from the rear: its back, not its faceplate
return `<div class="rack-plate rack-back">
${statusDot(item.status)}<a class="device-link rack-plate-name" href="${esc(item.url)}">${esc(item.name)}</a>
<span class="rack-plate-sub">back of a full-depth ${esc(KIND_TEXT[item.kind] || item.kind).toLowerCase()}</span>
</div>`;
}
function itemHtml(item) {
let body;
if (item.through) body = backHtml(item);
else if (item.switch && isRackFaceplate(item.switch.model)) body = switchHtml(item);
else if (CHASSIS_FACEPLATES[item.chassis]) body = switchHtml(item, CHASSIS_FACEPLATES[item.chassis]);
else if (item.chassis && RACK_FRONTS[item.chassis]) body = rackFrontSvg(item.chassis, item);
else if (item.kind === 'patch_panel' && item.chassis === 'uacc-patch-24') body = uaccPanelSvg(item);
else if (item.kind === 'patch_panel') body = panelSvg(item);
else if (item.kind === 'shelf') body = shelfHtml(item);
else body = plateHtml(item);
return `<div class="rack-item rack-kind-${esc(item.kind)}" data-item="${esc(item.id)}">${body}</div>`;
}
function uLabels(top, bottom) {
const spans = [];
for (let u = top; u >= bottom; u--) spans.push(`<span>${u}</span>`);
return `<div class="rack-u" aria-hidden="true">${spans.join('')}</div>`;
}
// Long runs of empty units are folded into one thin band unless the viewer asks for them
const GAP_MIN = 3;
function showEmpty() {
try { return localStorage.getItem('gandalf.rackShowEmpty') === '1'; } catch (_) { return false; }
}
function gapRow(top, bottom) {
const n = top - bottom + 1;
return `<div class="rack-row rack-row-gap" data-gap="${n}" style="--n:${n}">
<div class="rack-u" aria-hidden="true"></div>
<div class="rack-gap">U${bottom}-${top} · ${n}U free</div>
</div>`;
}
function row(top, bottom, inner, cls) {
const n = top - bottom + 1;
return `<div class="rack-row ${cls}" style="--n:${n}">
${uLabels(top, bottom)}
<div class="rack-slot" style="aspect-ratio:${RATIO} / ${n}">${inner}</div>
</div>`;
}
// ── Page ────────────────────────────────────────────────────────────────
function renderTabs(data) {
const tabs = document.getElementById('rack-tabs');
tabs.hidden = data.racks.length < 2;
tabs.innerHTML = data.racks.map(r => {
const on = r.name === data.rack;
return `<button type="button" class="rack-tab${on ? ' active' : ''}" role="tab" aria-selected="${on}"
data-rack="${esc(r.name)}">${esc(r.name)} <span class="rack-tab-count">${r.count}</span></button>`;
}).join('');
document.getElementById('rack-title').textContent = `${data.rack} · ${data.face}`;
document.querySelectorAll('.rack-face-btn').forEach(b => {
const on = b.dataset.face === data.face;
b.classList.toggle('active', on);
b.setAttribute('aria-pressed', on);
});
const rear = (data.racks.find(r => r.name === data.rack) || {}).rear || 0;
document.querySelector('.rack-face-btn[data-face="rear"]').textContent = rear ? `Rear (${rear})` : 'Rear';
}
function render(data) {
_rack = data;
renderTabs(data);
const byTop = Object.fromEntries(data.items.map(i => [i.rack_top, i]));
const rows = [];
let u = data.units;
while (u >= 1) {
const item = byTop[u];
if (item) {
rows.push(row(u, item.rack_u, itemHtml(item), 'rack-row-item'));
u = item.rack_u - 1;
continue;
}
let low = u;
while (low - 1 >= 1 && !byTop[low - 1]) low--;
rows.push(!showEmpty() && u - low + 1 >= GAP_MIN ? gapRow(u, low) : row(u, low, '', 'rack-row-empty'));
u = low - 1;
}
document.getElementById('rack').innerHTML = rows.join('');
// Every rack device is 19" wide: stretch a faceplate to fill its slot when its drawing is close to
// the slot's proportions. A drawing far from them (the PDU's is twice as tall as a real 1U) keeps its
// shape rather than being squashed.
document.querySelectorAll('#rack .rack-slot').forEach(slot => {
const svg = slot.querySelector('.fp-svg');
if (!svg) return;
const [, , w, h] = svg.getAttribute('viewBox').split(' ').map(Number);
const n = parseInt(slot.closest('.rack-row').style.getPropertyValue('--n'), 10);
const off = (w / h) / (RATIO / n);
svg.setAttribute('preserveAspectRatio', off > 0.85 && off < 1.15 ? 'none' : 'xMidYMid meet');
});
document.getElementById('rack-show-empty').checked = showEmpty();
document.getElementById('rack-count').textContent = data.items.length;
// Faceplate ports carry their cable run too, for hover and click
document.querySelectorAll('.rack-item .fp-port').forEach(g => {
const item = data.items.find(i => i.device === g.dataset.switch);
const m = item && item.ports[g.dataset.portIdx];
if (m) {
g.dataset.run = m.run.join(' ');
g.dataset.cable = m.cable_id;
}
});
const notes = [];
data.overlaps.forEach(o => notes.push(`<strong>${esc(o.name)}</strong> (${esc(o.units)}) overlaps ${esc(o.with.join(', '))} and is not drawn.`));
data.outside.forEach(o => notes.push(`<strong>${esc(o.name)}</strong> (${esc(o.units)}) is above the top of a ${data.units}U rack and is not drawn.`));
const warn = document.getElementById('rack-warnings');
warn.hidden = !notes.length;
warn.innerHTML = notes.length ? `<ul>${notes.map(n => `<li>${n}</li>`).join('')}</ul>
<p>Fix the rack unit on the <a href="/cutsheet#cs-items-section">cutsheet</a>.</p>` : '';
const unplaced = document.getElementById('rack-unplaced');
unplaced.innerHTML = data.unplaced.length
? `Not in the drawing (no rack unit set): ${data.unplaced.map(n => `<span class="cs-chip">${esc(n)}</span>`).join(' ')}`
: '';
if (!data.items.length) {
document.getElementById('rack').insertAdjacentHTML('afterbegin',
`<div class="lt-empty-state lt-empty-state--sm rack-empty"><div class="lt-empty-state-title">Nothing placed yet</div>
<div class="lt-empty-state-text">Give panels, shelves and devices a rack unit on the <a href="/cutsheet">cutsheet</a> and they appear here.</div></div>`);
}
}
function readout(el) {
const out = document.getElementById('rack-readout');
if (!el) {
out.textContent = 'Hover a port to follow its cable.';
return;
}
const title = el.querySelector('title');
out.textContent = title ? title.textContent : '';
}
function highlight(el) {
const ids = el && el.dataset.run ? el.dataset.run.split(' ') : [];
document.querySelectorAll('#rack [data-run]').forEach(x => {
x.classList.toggle('rack-hl', ids.length > 0 && x.dataset.run.split(' ').some(i => ids.includes(i)));
});
}
function portAt(target) {
return target.closest && target.closest('#rack .fp-port, #rack .rack-pp-port');
}
function onEnter(e) {
const el = portAt(e.target);
if (!el) return;
highlight(el);
readout(el);
}
function onLeave(e) {
const el = portAt(e.target);
if (el && !el.contains(e.relatedTarget)) {
highlight(null);
readout(null);
}
}
function openPort(el) {
if (el.classList.contains('fp-port')) {
const item = _rack && _rack.items.find(i => i.device === el.dataset.switch);
if (item && !item.linked) {
// A faceplate drawn by Front drawing for gear Gandalf can't see (the NVR) has no device page:
// open the port's cable if one is documented, otherwise the item on the cutsheet
location.href = el.dataset.cable ? `/cutsheet#cable-${encodeURIComponent(el.dataset.cable)}` : item.url;
return;
}
location.href = `/device/${encodeURIComponent(el.dataset.switch)}#port-${encodeURIComponent(el.dataset.portIdx)}`;
} else if (el.dataset.cable) {
location.href = `/cutsheet#cable-${encodeURIComponent(el.dataset.cable)}`;
}
}
const rackEl = document.getElementById('rack');
rackEl.addEventListener('mouseover', onEnter);
rackEl.addEventListener('mouseout', onLeave);
rackEl.addEventListener('focusin', onEnter);
rackEl.addEventListener('focusout', onLeave);
rackEl.addEventListener('click', e => {
const el = portAt(e.target);
if (el) openPort(el);
});
rackEl.addEventListener('keydown', e => {
const el = portAt(e.target);
if (el && (e.key === 'Enter' || e.key === ' ')) {
e.preventDefault();
openPort(el);
}
});
function currentRack() {
return new URLSearchParams(location.search).get('rack') || '';
}
function currentFace() {
return new URLSearchParams(location.search).get('face') === 'rear' ? 'rear' : 'front';
}
function setView(changes) {
const q = new URLSearchParams(location.search);
Object.entries(changes).forEach(([k, v]) => (v ? q.set(k, v) : q.delete(k)));
const qs = q.toString();
history.replaceState(null, '', qs ? `?${qs}` : location.pathname);
_rack = null;
load();
}
document.getElementById('rack-tabs').addEventListener('click', e => {
const tab = e.target.closest('[data-rack]');
if (!tab) return;
const first = _rack && _rack.racks[0] && _rack.racks[0].name;
setView({ rack: tab.dataset.rack === first ? '' : tab.dataset.rack });
});
document.querySelector('.rack-face').addEventListener('click', e => {
const btn = e.target.closest('[data-face]');
if (btn) setView({ face: btn.dataset.face === 'rear' ? 'rear' : '' });
});
async function load() {
try {
const q = new URLSearchParams();
if (currentRack()) q.set('rack', currentRack());
if (currentFace() === 'rear') q.set('face', 'rear');
render(await lt.api.get(`/api/rack${q.toString() ? `?${q}` : ''}`));
} catch (err) {
if (_rack) return; // keep the last drawing on a failed refresh
document.getElementById('rack').innerHTML = `<div class="lt-empty-state lt-empty-state--sm">
<div class="lt-empty-state-title">Could not load the rack</div>
<div class="lt-empty-state-text">${esc(err.message || err)}</div></div>`;
}
}
readout(null);
load();
setInterval(() => { if (!document.hidden && !document.querySelector('#rack .rack-hl')) load(); }, 60000);
// ── Export (SVG / PNG) ──────────────────────────────────────────────────
// Rebuilds the drawing as one standalone SVG on a white page, for printing or planning.
// Faceplates and panels are copied from the page with their computed styles inlined,
// since the stylesheet doesn't travel with the file.
const SVG_NS = 'http://www.w3.org/2000/svg';
const STYLE_PROPS = ['fill', 'fill-opacity', 'stroke', 'stroke-width', 'stroke-opacity', 'stroke-dasharray',
'stroke-linecap', 'stroke-linejoin', 'opacity', 'font-size', 'font-family', 'font-weight', 'letter-spacing',
'text-anchor', 'dominant-baseline', 'display', 'visibility'];
function inlineStyles(src, dst) {
const cs = getComputedStyle(src);
dst.setAttribute('style', STYLE_PROPS.map(p => `${p}:${cs.getPropertyValue(p)}`).join(';'));
dst.removeAttribute('class');
for (let i = 0; i < src.children.length; i++) inlineStyles(src.children[i], dst.children[i]);
}
function svgEl(tag, attrs, text) {
const el = document.createElementNS(SVG_NS, tag);
Object.entries(attrs).forEach(([k, v]) => el.setAttribute(k, v));
if (text != null) el.textContent = text;
return el;
}
function buildExport() {
document.querySelectorAll('#rack .rack-hl').forEach(el => el.classList.remove('rack-hl'));
const W = 1100, gutter = 46, pad = 20, head = 44, unit = W / RATIO;
const rows = [...document.querySelectorAll('#rack .rack-row')];
const height = rows.reduce((h, r) => h + (r.dataset.gap ? 26 : parseInt(r.style.getPropertyValue('--n'), 10) * unit), 0);
const H = head + height + pad * 2;
const root = svgEl('svg', { xmlns: SVG_NS, width: W + gutter + pad * 2, height: H,
viewBox: `0 0 ${W + gutter + pad * 2} ${H}`, 'font-family': 'Helvetica, Arial, sans-serif' });
root.appendChild(svgEl('rect', { width: '100%', height: '100%', fill: '#ffffff' }));
const stamp = new Date().toLocaleString();
root.appendChild(svgEl('text', { x: pad, y: pad + 14, 'font-size': 18, 'font-weight': 700, fill: '#111' },
`${_rack.rack} · ${_rack.face}`));
root.appendChild(svgEl('text', { x: W + gutter + pad, y: pad + 14, 'font-size': 11, fill: '#666', 'text-anchor': 'end' },
`Gandalf · ${stamp}`));
let y = head + pad;
const x = pad + gutter;
rows.forEach(row => {
const n = parseInt(row.style.getPropertyValue('--n'), 10);
if (row.dataset.gap) {
const band = 26;
root.appendChild(svgEl('rect', { x, y: y + 2, width: W, height: band - 4, fill: '#f4f5f7', stroke: '#d5d9de',
'stroke-dasharray': '4 4' }));
root.appendChild(svgEl('text', { x: x + W / 2, y: y + band / 2 + 4, 'font-size': 11, fill: '#777',
'text-anchor': 'middle' }, row.textContent.trim()));
y += band;
return;
}
const h = n * unit;
[...row.querySelectorAll('.rack-u span')].forEach((s, i) => {
root.appendChild(svgEl('text', { x: x - 8, y: y + unit * i + unit / 2 + 4, 'font-size': 11, fill: '#777',
'text-anchor': 'end' }, s.textContent));
});
const art = row.querySelector('svg.fp-svg, svg.rack-svg');
const plate = row.querySelector('.rack-plate');
if (art) {
const clone = art.cloneNode(true);
inlineStyles(art, clone);
['x', 'y', 'width', 'height'].forEach((k, i) => clone.setAttribute(k, [x, y, W, h][i]));
clone.setAttribute('preserveAspectRatio', art.getAttribute('preserveAspectRatio') || 'xMidYMid meet');
clone.removeAttribute('style');
root.appendChild(clone);
} else if (plate) {
root.appendChild(svgEl('rect', { x, y: y + 1, width: W, height: h - 2, rx: 3, fill: '#e9ecef', stroke: '#9aa3ad' }));
const name = plate.querySelector('.rack-plate-name, .rack-shelf-label');
const things = [...plate.querySelectorAll('.rack-shelf-name')].map(t => t.textContent);
const sub = things.length ? things.join(' · ') : (plate.querySelector('.rack-plate-sub') || {}).textContent || '';
root.appendChild(svgEl('text', { x: x + 16, y: y + h / 2 + (sub ? -2 : 5), 'font-size': 15, 'font-weight': 700,
fill: '#111' }, name ? name.textContent : ''));
if (sub) root.appendChild(svgEl('text', { x: x + 16, y: y + h / 2 + 15, 'font-size': 11, fill: '#444' }, sub));
} else {
root.appendChild(svgEl('rect', { x, y: y + 1, width: W, height: h - 2, fill: 'none', stroke: '#d5d9de',
'stroke-dasharray': '4 4' }));
}
y += h;
});
return new XMLSerializer().serializeToString(root);
}
function download(blob, name) {
const a = document.createElement('a');
a.href = URL.createObjectURL(blob);
a.download = name;
document.body.appendChild(a);
a.click();
a.remove();
setTimeout(() => URL.revokeObjectURL(a.href), 10000);
}
async function exportRack(kind) {
if (!_rack || !_rack.items.length) {
lt.toast.error('Nothing in this rack to export yet');
return;
}
const svg = buildExport();
const base = `${_rack.rack.replace(/[^\w.-]+/g, '-')}-${_rack.face}`;
if (kind === 'svg') {
download(new Blob([svg], { type: 'image/svg+xml' }), `${base}.svg`);
return;
}
const img = new Image();
const url = URL.createObjectURL(new Blob([svg], { type: 'image/svg+xml' }));
try {
await new Promise((resolve, reject) => { img.onload = resolve; img.onerror = reject; img.src = url; });
const scale = 2;
const canvas = document.createElement('canvas');
canvas.width = img.width * scale;
canvas.height = img.height * scale;
const ctx = canvas.getContext('2d');
ctx.scale(scale, scale);
ctx.drawImage(img, 0, 0);
canvas.toBlob(blob => download(blob, `${base}.png`), 'image/png');
} catch (err) {
lt.toast.error('Could not render the PNG; try the SVG');
} finally {
URL.revokeObjectURL(url);
}
}
document.getElementById('rack-show-empty').addEventListener('change', e => {
try { localStorage.setItem('gandalf.rackShowEmpty', e.target.checked ? '1' : '0'); } catch (_) { /* private mode */ }
if (_rack) render(_rack);
});
document.querySelectorAll('[data-export]').forEach(btn => btn.addEventListener('click', () => exportRack(btn.dataset.export)));
// ── Rack settings (admins) ──────────────────────────────────────────────
function openRackForm(adding) {
const form = document.getElementById('rack-form');
form.reset();
const r = adding ? null : (_rack.racks.find(x => x.name === _rack.rack) || {});
form.id.value = r && r.id ? r.id : '';
// The default rack exists only in config until saved; its items follow the new name
form.previous.value = r && !r.id ? r.name : '';
form.name.value = r ? r.name : '';
form.units.value = r ? r.units : 42;
form.notes.value = r ? (r.notes || '') : '';
form.querySelector('[data-action="delete-rack"]').hidden = !(r && r.id);
document.getElementById('rack-modal-title').textContent = adding ? 'Add a rack' : 'Rack settings';
lt.modal.open('rack-modal');
form.name.focus();
}
async function saveRack(e) {
e.preventDefault();
const form = e.target;
const body = { name: form.name.value.trim(), units: form.units.value, notes: form.notes.value, previous: form.previous.value };
try {
if (form.id.value) await lt.api.put(`/api/cutsheet/racks/${encodeURIComponent(form.id.value)}`, body);
else await lt.api.post('/api/cutsheet/racks', body);
lt.modal.close('rack-modal');
lt.toast.success('Rack saved');
setView({ rack: body.name });
} catch (err) {
lt.toast.error(err.message || 'Save failed');
}
}
async function deleteRack() {
const form = document.getElementById('rack-form');
if (!form.id.value || !window.confirm(`Delete the rack ${form.name.value}?`)) return;
try {
await lt.api.delete(`/api/cutsheet/racks/${encodeURIComponent(form.id.value)}`);
lt.modal.close('rack-modal');
lt.toast.success('Rack deleted');
setView({ rack: '' });
} catch (err) {
lt.toast.error(err.message || 'Delete failed');
}
}
if (RACK_CAN_EDIT) {
document.querySelector('[data-action="rack-settings"]').addEventListener('click', () => _rack && openRackForm(false));
document.querySelector('[data-action="add-rack"]').addEventListener('click', () => _rack && openRackForm(true));
document.getElementById('rack-form').addEventListener('submit', saveRack);
document.querySelector('[data-action="delete-rack"]').addEventListener('click', deleteRack);
}
+418 -6
View File
@@ -1,5 +1,5 @@
/* ══════════════════════════════════════════════════════════════════════
GANDALF – App-specific styles (extends LotusGuild base.css)
GANDALF: App-specific styles (extends LotusGuild base.css)
base.css handles: body, header, nav, tables, buttons, forms, modals,
badges, toasts, layout shell, and the full design token system.
This file adds only gandalf-specific components.
@@ -96,7 +96,7 @@
content: '…';
}
/* ── Secondary button – dark-mode definition ─────────────────────────
/* ── Secondary button: dark-mode definition ─────────────────────────
base.css only defines .lt-btn-secondary in its light-theme block,
so dark mode falls back to the default cyan primary appearance.
This restores a visually distinct secondary look in dark mode. */
@@ -317,7 +317,7 @@
overflow: hidden;
transition: border-color .2s, box-shadow .2s;
}
/* Corner accent triangle — mirrors test code's status-tinted corner */
/* Corner accent triangle: mirrors test code's status-tinted corner */
.host-card::after {
content: '';
position: absolute;
@@ -485,7 +485,7 @@
transition: border-color .2s, box-shadow .2s;
overflow: hidden;
}
/* Top highlight strip — color matches node type / status */
/* Top highlight strip: color matches node type / status */
.topo-v2-node::before {
content: '';
position: absolute;
@@ -712,7 +712,7 @@
.counter-zero { color: var(--green); }
.counter-nonzero { color: var(--red); text-shadow: var(--glow-red); }
/* Traffic bars — use lt-progress from base.css */
/* Traffic bars: use lt-progress from base.css */
.traffic-section { margin-top: 8px; padding-top: 8px; border-top: 1px solid rgba(255,107,0,.08); }
.traffic-row { display: flex; align-items: center; gap: 8px; margin-bottom: 5px; }
.traffic-label { font-size: .62em; color: var(--text-muted); width: 20px; text-transform: uppercase; letter-spacing: .04em; flex-shrink: 0; }
@@ -945,7 +945,7 @@
transition: all .15s;
}
.panel-close:hover { color: var(--red); border-color: var(--red); }
/* Inspector panel uses lt-divider — compact spacing overrides */
/* Inspector panel uses lt-divider: compact spacing overrides */
.inspector-panel .lt-divider { margin: 8px 0 4px; }
.inspector-panel .lt-divider-label { color: var(--amber); font-size: .6em; }
.panel-row {
@@ -1172,3 +1172,415 @@ tr.device-row.is-selected { background: var(--bg-tertiary); box-shadow: inset 3p
.device-inspector .inspector-panel-inner { width: 100%; max-height: none; }
.device-chassis .chassis-ear-l, .device-chassis .chassis-ear-r { display: none; }
}
/* ── Realistic device faceplates (static/faceplates.js) ───────────── */
/* Hardware colors are fixed: a silver chassis stays silver in every theme. */
.device-chassis { container-type: inline-size; }
.fp-wrap { padding: 14px 16px; }
.fp-frame { overflow: hidden; border-radius: 3px; box-shadow: 0 2px 10px rgba(0,0,0,.55); }
.fp-svg { display: block; width: 100%; height: auto; }
/* Too narrow for the whole unit: zoom to the port area so jacks stay tappable.
Width = viewBox width / visible width; margin = cropX / visible width. */
@container (max-width: 620px) {
.fp-crop-udmpro .fp-svg { width: 308.7%; max-width: none; margin-left: -208.7%; }
}
.fp-body { fill: url(#fp-metal); }
.fp-vent { fill: #242326; }
.fp-screen { fill: #0c1020; stroke: #2a2c34; stroke-width: 1; }
.fp-screen-ring{ fill: none; stroke: #3f7bd9; stroke-width: 2.2; }
.fp-screen-dot { fill: #dfe8f8; }
.fp-brand { fill: #2e2f33; font: 700 7.5px Arial, Helvetica, sans-serif; }
.fp-brand-light{ font-weight: 400; fill: #55565c; }
.fp-brand-bolt-ring { fill: #2e2f33; }
.fp-brand-bolt { fill: #e4e4e6; }
.fp-bay { fill: url(#fp-bay-face); stroke: #54555a; stroke-width: 1; }
.fp-bay-edge { fill: #bdbdc1; }
.fp-bay-led { fill: #3a3a3e; }
.fp-block { fill: #e1e1e3; stroke: #5d5e63; stroke-width: 1; }
.fp-divider { fill: #dcdcde; }
.fp-label { fill: #55565c; font: 9px Arial, Helvetica, sans-serif; }
.fp-label-sm { font-size: 6.5px; letter-spacing: .03em; }
.fp-globe { fill: none; stroke: #3f7bd9; stroke-width: .8; }
.fp-reset { fill: #1b1b1d; }
.fp-jack { fill: #18181b; stroke: #0c0c0d; stroke-width: .6; }
.fp-contacts { fill: #b89545; }
.fp-plug { fill: #9ea1a8; stroke: #5b5d63; stroke-width: .6; }
.fp-plug-clip { fill: #7e8087; stroke: #5b5d63; stroke-width: .5; }
.fp-cage { fill: #17171a; stroke: #6e6f74; stroke-width: 1; }
.fp-cage-spring{ fill: none; stroke: #5d5e63; stroke-width: 1.2; stroke-dasharray: 2.5 1.5; }
.fp-cage-rail { fill: #3b3c41; }
.fp-module { fill: #a5a7ad; stroke: #6a6b70; stroke-width: .6; }
.fp-module-lc { fill: #2a4a7f; stroke: #1a2a44; stroke-width: .5; }
.fp-module-fault { stroke: #e0312b; stroke-width: 1.4; }
.fp-dac-boot { fill: #2b2c30; stroke: #17171a; stroke-width: .5; }
.fp-dac-cable { fill: #111113; }
.fp-led-idle { fill: #6a6b70; }
.fp-led-off { fill: #4b4c50; }
.fp-led-amber { fill: #ffad1f; }
.fp-led-green { fill: #35f06f; }
.fp-led-white { fill: #ffffff; stroke: #8fa6c4; stroke-width: .5; }
.fp-led-unknown{ fill: #b9bcc2; }
.fp-led-amber, .fp-led-green, .fp-led-white { filter: drop-shadow(0 0 1.5px currentColor); }
.fp-led-amber { color: #ffad1f; }
.fp-led-green { color: #35f06f; }
.fp-led-white { color: #cfe2ff; }
.fp-led-active { animation: fp-blink 1.3s steps(2, jump-none) infinite; }
@keyframes fp-blink { 50% { opacity: .45; } }
@media (prefers-reduced-motion: reduce) { .fp-led-active { animation: none; } }
.fp-port { cursor: pointer; outline: none; }
.fp-hit { fill: transparent; stroke: transparent; stroke-width: 2.5; pointer-events: all; }
.fp-port:hover .fp-hit { stroke: rgba(0,90,220,.55); }
.fp-port:focus-visible .fp-hit,
.fp-port.selected .fp-hit { stroke: #0058e0; fill: rgba(0,88,224,.14); }
.fp-legend-led { width: 12px; height: 5px; border-radius: 1px; display: inline-block; background: #4b4c50; }
.fp-legend-led.fp-led-amber { background: #ffad1f; }
.fp-legend-led.fp-led-green { background: #35f06f; }
.fp-legend-led.fp-led-white { background: #fff; }
.fp-readout { margin-left: auto; font-size: .72em; color: var(--text-dim, var(--text-muted)); text-transform: none; letter-spacing: 0; }
/* Narrow panels: crop to the ports, or scroll within the panel */
@container (max-width: 620px) {
.fp-crop-agg .fp-svg { width: 437%; max-width: none; margin-left: -337%; }
.fp-scroll { overflow-x: auto; }
.fp-scroll .fp-svg { width: 260%; max-width: none; }
}
.fp-desk { box-shadow: none; }
.fp-desk .fp-svg { max-width: 560px; margin: 0 auto; filter: drop-shadow(0 3px 6px rgba(0,0,0,.5)); }
.fp-body-white { fill: #f2f2f3; stroke: #c9c9cc; stroke-width: 1; }
.fp-frame-grey { fill: #c6c8cc; stroke: #8b8d92; stroke-width: 1; }
.fp-foot { fill: #b7b7ba; }
.fp-body-metal { fill: url(#fp-metal); }
.fp-ear { fill: #c4c4c7; stroke: #8f9095; stroke-width: 1; }
.fp-ear-hole { fill: #0b0d12; }
.fp-button { fill: #3a3a3e; stroke: #1b1b1d; stroke-width: 1; }
.fp-speed-bar { fill: #8d8e93; }
.fp-screen-grid{ fill: none; stroke: #2f6fd0; stroke-width: 1; }
.fp-screen-icon{ fill: #6b9be4; }
.fp-static { opacity: .85; }
.fp-bolt { fill: #e88a00; }
.fp-cycle { fill: none; stroke: #0058e0; stroke-width: 1.4; stroke-linecap: round; }
.fp-outlet { cursor: default; outline: none; }
.fp-outlet-face { fill: #2a2a2d; stroke: #111113; stroke-width: 1; }
.fp-slot { fill: #050506; }
.fp-usbc { fill: #1c1c1f; stroke: #8b8d92; stroke-width: 1; }
.fp-usbc-tongue { fill: #b9bcc2; }
.fp-outlet-is-off .fp-outlet-face { fill: #5b5c60; }
.fp-outlet-is-off .fp-usbc { fill: #66676b; }
.fp-outlet:hover .fp-hit { stroke: rgba(0,90,220,.55); }
.fp-outlet:focus-visible .fp-hit { stroke: #0058e0; fill: rgba(0,88,224,.14); }
.fp-outlet-state { fill: #8d8e93; }
.fp-state-on { fill: #12a84a; }
.fp-state-off { fill: #d6332a; }
.fp-ups-band { fill: #8c8d90; }
.fp-ups-vent { fill: #2b2b2e; }
.fp-ups-rib { fill: none; stroke: #77787c; stroke-width: 1; }
.fp-ups-batt { fill: none; stroke: #2b2b2e; stroke-width: 1.3; }
.fp-ups-batt-tip{ fill: #2b2b2e; }
.fp-led-blue { fill: #2f7bff; color: #2f7bff; filter: drop-shadow(0 0 2px currentColor); }
.fp-legend-led.fp-led-blue { background: #2f7bff; }
.fp-legend-led.fp-led-outlet-on { background: #12a84a; width: 7px; height: 7px; border-radius: 50%; }
.fp-legend-led.fp-led-outlet-off { background: #d6332a; width: 7px; height: 7px; border-radius: 50%; }
.fp-legend-icon { width: 11px; height: 11px; flex-shrink: 0; }
/* A white LED needs an edge to show against the light metal around it */
polygon.fp-led-white { stroke: #6b7c95; stroke-width: .7; }
polygon.fp-led-off { fill: #6b6c71; }
.fp-key { fill: none; stroke: #55565c; stroke-width: .8; }
.fp-key-amber { fill: #e8762c; stroke: none; }
.fp-key-green { fill: #7ec23a; stroke: none; }
.fp-ups-bolt { fill: #2b2b2e; }
/* UPS 2U Pro: front and rear panels stacked */
.fp-stack { box-shadow: none; }
.fp-caption { fill: #8b96a6; font: 600 10px Arial, Helvetica, sans-serif; letter-spacing: .1em; }
.fp-ups-band-light { fill: #f4f4f5; }
.fp-power-ring { fill: none; stroke: #8d8e93; stroke-width: 3; }
.fp-power-on { stroke: #2f9bff; filter: drop-shadow(0 0 3px #2f9bff); }
.fp-power-face { fill: #dcdcde; stroke: #a9a9ad; stroke-width: 1; }
.fp-power-icon { fill: none; stroke: #55565c; stroke-width: 1.5; stroke-linecap: round; }
.fp-tile { fill: #1f6fff; }
.fp-tile-num { fill: #fff; font: 600 9px Arial, Helvetica, sans-serif; }
.fp-outlet-is-off .fp-tile { fill: #3a3d46; }
.fp-screen-tile-dim{ fill: #2a2d36; }
.fp-breaker { fill: #4a4a4e; }
.fp-fan { fill: none; stroke: #3a3a3e; stroke-width: 7; }
.fp-fan-strut { fill: none; stroke: #c9c9cc; stroke-width: 5; }
.fp-epo { fill: #1c1c1f; }
.fp-bracket { fill: none; stroke: #55565c; stroke-width: 1; }
/* ── Cutsheet ─────────────────────────────────────────────────────────── */
.cutsheet-check { font-size: 12px; padding: 2px 0; overflow-wrap: anywhere; }
.cutsheet-path { font-size: 11px; color: var(--text-muted, #8aa); padding: 2px 0 8px; overflow-wrap: anywhere; }
.cs-more { margin-top: 8px; }
/* Button styles set display, which would otherwise override the hidden attribute */
.lt-btn[hidden], .cs-link-btn[hidden] { display: none !important; }
.cs-trace { margin-bottom: 16px; }
.cs-trace-form { display: flex; flex-wrap: wrap; gap: 12px; align-items: flex-end; }
.cs-trace-form .lt-form-group { margin: 0; min-width: 120px; }
.cs-trace-buttons { display: flex; gap: 8px; }
.cs-trace-status { margin-top: 10px; font-size: .88rem; line-height: 1.6; }
.cs-trace-found { font-size: 1rem; margin-bottom: 6px; }
.cs-actions { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; }
.cs-summary { display: flex; flex-wrap: wrap; gap: 8px; margin: 0 0 18px; }
.cs-chip { padding: 5px 10px; border: 1px solid var(--border-color, #234); border-radius: 3px; font-size: .82rem;
color: inherit; text-decoration: none; }
.cs-chip b { font-size: .95rem; }
.cs-chip-ok b { color: var(--status-ok, #2ecc71); }
.cs-chip-bad { border-color: var(--status-critical, #e0312b); }
.cs-chip-bad b { color: var(--status-critical, #e0312b); }
.cs-chip-warn b { color: var(--accent-amber, #f0a020); }
.cs-filters { display: flex; flex-wrap: wrap; gap: 10px; align-items: center; margin-bottom: 10px; }
.cs-filters .lt-input { flex: 1 1 240px; min-width: 0; }
.cs-filters .lt-select { flex: 0 1 180px; }
.cs-check { display: inline-flex; gap: 6px; align-items: center; font-size: .85rem; cursor: pointer; }
.cs-hint { font-size: .82rem; color: var(--text-muted, #8aa); margin: 0 0 10px; max-width: 75ch; }
.cs-table td { vertical-align: top; }
.cs-id { font-weight: 700; white-space: nowrap; }
.cs-port, .cs-side-tag { font-size: .8rem; color: var(--text-muted, #8aa); }
.cs-side-tag { text-transform: uppercase; letter-spacing: .04em; }
.cs-path, .cs-detail { font-size: .76rem; color: var(--text-muted, #8aa); margin-top: 3px; }
.cs-tag { font-size: .68rem; padding: 1px 5px; border: 1px solid var(--accent-amber, #f0a020); color: var(--accent-amber, #f0a020);
border-radius: 2px; white-space: nowrap; }
.cs-row-problem td:first-child { box-shadow: inset 3px 0 0 var(--status-critical, #e0312b); }
.cs-flash { animation: cs-flash 2.4s ease-out 1; }
@keyframes cs-flash { from { background: rgba(240,160,32,.28); } to { background: transparent; } }
@media (prefers-reduced-motion: reduce) { .cs-flash { animation: none; outline: 2px solid var(--accent-amber, #f0a020); } }
.cs-panel { margin-bottom: 16px; }
.cs-link-btn { background: none; border: 0; padding: 0 0 0 6px; color: var(--accent-cyan, #3cc); cursor: pointer;
font: inherit; font-size: .78rem; text-decoration: underline; }
.cs-label-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(220px, 1fr)); gap: 8px; }
.cs-label-card { display: grid; grid-template-columns: auto 1fr auto; gap: 2px 8px; align-items: center;
padding: 8px 10px; border: 1px dashed var(--border-color, #234); border-radius: 3px; }
.cs-label-text { font-family: var(--font-mono, monospace); font-size: 1.05rem; font-weight: 700; letter-spacing: .05em; }
.cs-label-copies { font-size: .8rem; color: var(--text-muted, #8aa); }
.cs-label-where { grid-column: 1 / -1; font-size: .74rem; color: var(--text-muted, #8aa); }
.cs-rack { display: flex; flex-direction: column; gap: 3px; max-width: 560px; }
.cs-rack-unit { display: grid; grid-template-columns: 70px 1fr auto; gap: 10px; align-items: center;
min-height: calc(var(--u, 1) * 26px); padding: 4px 10px; border: 1px solid var(--border-color, #234);
border-radius: 2px; background: rgba(255,255,255,.02); }
.cs-rack-u { font-family: var(--font-mono, monospace); font-size: .78rem; color: var(--text-muted, #8aa); }
.cs-rack-kind { font-size: .74rem; color: var(--text-muted, #8aa); }
.cs-end { border: 1px solid var(--border-color, #234); border-radius: 3px; padding: 4px 12px 0; margin: 0 0 12px; }
.cs-end legend { font-size: .78rem; padding: 0 6px; color: var(--text-muted, #8aa); text-transform: uppercase; }
.cs-side[hidden] { display: none; }
.cs-modal-wide { max-width: 720px; width: calc(100vw - 32px); }
.cs-mono { font-family: var(--font-mono, monospace); font-size: .8rem; }
.cs-errors ul { margin: 6px 0 0 18px; font-size: .8rem; }
@media (max-width: 640px) {
/* Cables become cards: one labeled field per line */
.cs-table thead { display: none; }
.cs-table, .cs-table tbody, .cs-table tr, .cs-table td { display: block; width: 100%; }
.cs-table tr { border: 1px solid var(--border-color, #234); border-radius: 3px; margin-bottom: 10px; padding: 6px 10px; }
.cs-table td { border: 0 !important; padding: 3px 0 !important; overflow-wrap: anywhere; }
.cs-table td[data-label]::before { content: attr(data-label); display: block; font-size: .68rem;
text-transform: uppercase; letter-spacing: .06em; color: var(--text-muted, #8aa); }
.cs-table td.cs-id { font-size: 1rem; }
.cs-row-problem { box-shadow: inset 3px 0 0 var(--status-critical, #e0312b); }
.cs-row-problem td:first-child { box-shadow: none; }
.cs-rack-unit { grid-template-columns: 56px 1fr; }
.cs-rack-kind { display: none; }
}
@media print {
.no-print, .lt-header, .lt-nav-drawer, .lt-nav-drawer-overlay { display: none !important; }
body.cs-print-labels .g-section:not(#cs-labels-section),
body.cs-print-labels .lt-page-header, body.cs-print-labels .cs-summary { display: none !important; }
.cs-label-card { break-inside: avoid; border-color: #000; color: #000; }
.lt-table, .lt-table td, .lt-table th { color: #000 !important; }
}
/* ── Alert history (/events) ───────────────────────────────────────── */
.ev-filters .lt-select { flex: 0 1 170px; }
.ev-type-chip { background: none; cursor: pointer; font: inherit; font-size: .82rem; }
.ev-type-chip:hover, .ev-type-chip:focus-visible { border-color: var(--accent-cyan); }
.ev-type-chip.active { border-color: var(--accent-cyan); background: var(--accent-cyan-dim); }
.ev-link { background: none; border: 0; padding: 0; color: inherit; font: inherit; cursor: pointer;
text-decoration: underline dotted; text-underline-offset: 3px; text-align: left; }
.ev-link:hover, .ev-link:focus-visible { color: var(--accent-cyan); }
.ev-table td { vertical-align: top; }
.ev-table .cs-port { display: block; }
.ev-pager { display: flex; gap: 12px; align-items: center; justify-content: center; margin-top: 12px; font-size: .85rem; }
.g-section-more { margin: 10px 12px 4px; font-size: .85rem; }
.ev-table .lt-badge, .ev-c-type { white-space: nowrap; }
/* Phones: each alert becomes a card instead of a squeezed table row */
@media (max-width: 760px) {
.ev-cards thead { display: none; }
.ev-cards, .ev-cards tbody { display: block; width: 100%; }
.ev-cards tr { display: flex; flex-wrap: wrap; align-items: baseline; gap: 4px 14px; padding: 10px 12px;
border-bottom: 1px solid var(--border-color); }
.ev-cards td { display: block; padding: 0; border: 0; max-width: none; white-space: normal; font-size: .82rem; }
.ev-cards td[data-label]::before { content: attr(data-label) " "; color: var(--text-muted); font-size: .72rem;
text-transform: uppercase; letter-spacing: .05em; }
.ev-cards .ev-c-target { flex: 1 1 100%; order: -1; font-size: .95rem; }
.ev-cards .ev-c-target .cs-port { display: inline; margin-left: 6px; }
.ev-cards .ev-c-desc { flex: 1 1 100%; color: var(--text-muted); white-space: normal; overflow: visible; }
.ev-cards .ev-c-action { flex: 1 1 100%; }
}
/* ── Cutsheet marks on faceplates ──────────────────────────────────── */
.fp-mark { stroke: #101418; stroke-width: 1.2; pointer-events: none; }
.fp-mark-ok { fill: var(--accent-green, #00ff88); }
.fp-mark-bad { fill: var(--status-critical, #e0312b); }
.fp-mark-doc { fill: #9aa7b4; }
body.fp-marks-off .fp-svg .fp-mark { display: none; }
.fp-mark-toggle { cursor: pointer; gap: 6px; }
.fp-mark-toggle input { margin: 0; }
/* ── Rack (/rack) ──────────────────────────────────────────────────── */
/* The rack is hardware: it keeps its own palette in both themes so labels inside it stay readable */
.rack {
--rk-frame: #0b0f14; --rk-edge: #2a3440; --rk-text: #e6edf3; --rk-muted: #8b97a5; --rk-line: rgba(255,255,255,.07);
--rk-plate-a: #232a33; --rk-plate-b: #1a2028; --rk-plate-edge: #2d3743; --rk-link: #6fd3ff;
max-width: 1000px; margin: 0 auto; display: flex; flex-direction: column; gap: 2px; padding: 10px 12px 10px 0;
background: var(--rk-frame); border: 1px solid var(--rk-edge); border-radius: 4px; color: var(--rk-text); }
[data-theme="light"] .rack {
--rk-frame: #2b3139; --rk-edge: #1d2228; --rk-muted: #a9b4c0; --rk-line: rgba(255,255,255,.10);
--rk-plate-a: #3a424d; --rk-plate-b: #313841; --rk-plate-edge: #4a5461; --rk-link: #8fdcff;
box-shadow: 0 6px 18px rgba(20,30,45,.25); }
.rack-row { display: grid; grid-template-columns: 34px 1fr; }
.rack-u { display: flex; flex-direction: column; font-size: .62rem; color: var(--rk-muted); text-align: right;
padding-right: 6px; font-family: var(--font-mono, monospace); }
.rack-u span { flex: 1; display: flex; align-items: center; justify-content: flex-end; }
.rack-slot { position: relative; min-width: 0; }
.rack-row-empty .rack-slot { background: repeating-linear-gradient(to bottom, transparent 0 calc(100% / var(--n) - 1px),
var(--rk-line) calc(100% / var(--n) - 1px) calc(100% / var(--n))); border: 1px dashed var(--rk-line); }
.rack-item, .rack-item .fp-wrap, .rack-item .fp-frame { height: 100%; }
.rack-item .fp-wrap { padding: 0; }
.rack-item .fp-frame { box-shadow: none; overflow: hidden; }
.rack-item .fp-svg { width: 100%; height: 100%; }
.rack-item .chassis-legend { display: none; }
.rack-svg { display: block; width: 100%; height: 100%; }
.rack-plate { height: 100%; display: flex; align-items: center; gap: 14px; padding: 0 18px; border-radius: 3px;
background: linear-gradient(var(--rk-plate-a), var(--rk-plate-b)); border: 1px solid var(--rk-plate-edge); }
.rack .rack-plate-name { font-weight: 700; color: var(--rk-text); text-decoration-color: var(--rk-muted); }
.rack .rack-plate-name:hover, .rack .rack-plate-name:focus-visible { color: var(--rk-link); }
.rack-plate-sub { font-size: .78rem; color: var(--rk-muted); }
.rack-kind-shelf .rack-plate { background: repeating-linear-gradient(90deg, var(--rk-plate-b) 0 10px, var(--rk-frame) 10px 20px); }
.rack-pp-body { fill: #1d2229; stroke: #39424e; }
/* The panel's name sits in its top-left corner, above the port numbers, so a long name can't run under the ports */
.rack-pp-name { fill: #9aa7b4; font-size: 12px; font-family: var(--font-mono, monospace); }
.rack-pp-num { fill: #7d8a97; font-size: 10px; }
.rack-pp-label { fill: #c9d3dc; font-size: 9px; }
.rack-pp-jack { fill: #0c0f13; stroke: #4a5560; stroke-width: 1.5; }
.rack-pp-ok .rack-pp-jack { stroke: #00e07a; }
.rack-pp-bad .rack-pp-jack { stroke: var(--status-critical, #e0312b); stroke-width: 2.5; }
.rack-pp-doc .rack-pp-jack { stroke: #9aa7b4; }
.rack-pp-hit { fill: transparent; }
.rack-pp-port[data-cable] { cursor: pointer; outline: none; }
/* A hovered run: every port on it */
.rack-pp-port.rack-hl .rack-pp-jack { fill: rgba(0,212,255,.35); stroke: #00d4ff; stroke-width: 3; }
.rack .fp-port.rack-hl .fp-hit { stroke: #00b8e6; stroke-width: 4; fill: rgba(0,212,255,.3); }
.rack-readout, .rack-legend, .rack-unplaced, .rack-tabs, .rack-warnings { max-width: 1000px;
margin-left: auto !important; margin-right: auto !important; }
.rack-readout { min-height: 1.4em; margin: 0 0 8px; font-size: .85rem; color: var(--accent-cyan); }
.rack-legend { display: flex; flex-wrap: wrap; gap: 14px; font-size: .75rem; color: var(--text-muted); margin-bottom: 8px; }
.rack-key { display: inline-block; width: 10px; height: 10px; border-radius: 50%; margin-right: 6px; vertical-align: -1px; }
.rack-key-ok { background: var(--accent-green); }
.rack-key-bad { background: var(--status-critical, #e0312b); }
.rack-key-doc { background: #9aa7b4; }
.rack-warnings { border: 1px solid var(--status-critical, #e0312b); padding: 8px 14px; margin-bottom: 14px; font-size: .85rem; }
.rack-warnings ul { margin: 0 0 6px; padding-left: 18px; }
.rack-warnings p { margin: 0; }
.rack-unplaced { margin-top: 12px; display: flex; flex-wrap: wrap; gap: 6px; align-items: center; }
.rack-empty { margin: 12px; }
.rack-gap { height: 26px; display: flex; align-items: center; justify-content: center; font-size: .72rem;
color: var(--rk-muted); border: 1px dashed var(--rk-line); letter-spacing: .04em; }
.rack-toggle { margin-left: auto; display: inline-flex; gap: 6px; align-items: center; cursor: pointer; }
.rack-legend { align-items: center; }
@media (max-width: 600px) {
.rack-row { grid-template-columns: 22px 1fr; }
.rack-u { font-size: .5rem; padding-right: 3px; }
.rack-plate { padding: 0 8px; gap: 8px; }
.rack-plate-sub { display: none; }
}
.rack-tabs { display: flex; flex-wrap: wrap; gap: 6px; margin-bottom: 14px; }
.rack-tab { background: none; border: 1px solid var(--border-color); color: inherit; font: inherit; font-size: .85rem;
padding: 6px 12px; cursor: pointer; border-radius: 3px; }
.rack-tab.active { border-color: var(--accent-cyan); background: var(--accent-cyan-dim); }
.rack-tab-count { color: var(--text-muted); font-size: .75rem; margin-left: 4px; }
.rack-shelf { gap: 10px; padding: 0 10px; container-type: size; }
.rack-shelf-label { font-size: .72rem; color: var(--rk-muted); white-space: nowrap; writing-mode: horizontal-tb; }
.rack-shelf-things { display: flex; gap: 6px; flex: 1; min-width: 0; height: 78%; }
.rack-shelf-thing { flex: 1 1 0; min-width: 0; display: flex; align-items: center; justify-content: center; gap: 6px;
padding: 0 6px; border-radius: 3px; background: linear-gradient(#e6e8eb, #c9cdd2); color: #15191e;
text-decoration: none; font-size: .78rem; font-weight: 600; box-shadow: 0 1px 2px rgba(0,0,0,.5); }
.rack-shelf-thing:hover, .rack-shelf-thing:focus-visible { outline: 2px solid var(--accent-cyan); }
.rack-shelf-name { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
@container (max-height: 50px) { .rack-shelf-label { display: none; } .rack-shelf-thing { font-size: .6rem; gap: 3px; } }
.rack-bar { display: flex; flex-wrap: wrap; gap: 10px; align-items: center; justify-content: space-between;
max-width: 1000px; margin: 0 auto 14px; }
.rack-bar .rack-tabs { margin: 0 !important; }
.rack-face { display: inline-flex; border: 1px solid var(--border-color); border-radius: 3px; overflow: hidden; margin-left: auto; }
.rack-face-btn { background: none; border: 0; color: inherit; font: inherit; font-size: .82rem; padding: 6px 14px; cursor: pointer; }
.rack-face-btn + .rack-face-btn { border-left: 1px solid var(--border-color); }
.rack-face-btn.active { background: var(--accent-cyan-dim); color: var(--accent-cyan); }
.rack-back { opacity: .75; background: repeating-linear-gradient(135deg, var(--rk-plate-b) 0 8px, var(--rk-frame) 8px 16px); }
/* ── Drawn rack fronts (static/fronts.js) ─────────────────────────── */
.rf-ear, .rf-ear-dark { fill: #2b3037; }
.rf-ear { fill: #c9cbcf; }
.rf-slot { fill: #0d1014; }
.rf-vent { fill: #14181d; }
.rf-body-dark { fill: #1e2329; stroke: #3a424c; }
.rf-blank { fill: #262c33; stroke: #3d4651; }
.rf-bay { fill: #2c333b; stroke: #4c5662; stroke-width: 1.5; }
.rf-latch { fill: #8a96a3; }
.rf-bay-led { fill: #3b8bff; opacity: .8; }
.rf-io { fill: #171b20; stroke: #333b45; }
.rf-power-ring { fill: none; stroke-width: 3; }
.rf-power-icon { fill: none; stroke: #c7ced6; stroke-width: 2.4; stroke-linecap: round; }
.rf-port { fill: #0b0d10; stroke: #6b737d; }
.rf-port-tongue { fill: #2f6fd8; }
.rf-port-led { fill: #2fd36b; }
.rf-lock { fill: #a7b0ba; }
.rf-lock-slot { fill: #2b3037; }
.rf-led { fill: #6b737d; }
.rf-reset { fill: #0b0d10; stroke: #6b737d; }
.rf-brand { fill: #c3ccd5; font-size: 12px; font-weight: 700; letter-spacing: .14em; font-family: Helvetica, Arial, sans-serif; }
.rf-small { fill: #4a4f57; font-size: 10px; font-family: Helvetica, Arial, sans-serif; }
.rf-dark { fill: #1b1e22; font-weight: 700; }
.rf-door { fill: #121519; stroke: #3a424c; stroke-width: 2; }
.rf-mesh { stroke: #262c33; stroke-width: 2; opacity: .55; }
.rf-perf-hole { fill: #000; }
.rf-door-latch { fill: #3a424c; stroke: #59636f; }
.rf-bay-num { fill: #8a96a3; font-size: 11px; font-family: Helvetica, Arial, sans-serif; }
.rf-fan { fill: #15191e; stroke: #2e353e; stroke-width: 6; }
.rf-fan-hub { fill: #262c33; }
.rf-fan-blade { fill: #1f252c; stroke: #2e353e; }
.rf-handle { fill: none; stroke: #8a96a3; stroke-width: 5; }
.rf-unvr-body { fill: #d9dadc; stroke: #a9abaf; }
.rf-unvr-strip { fill: #26282c; }
.rf-unvr-bay { fill: #e9eaec; stroke: #9fa2a7; stroke-width: 1.5; }
.rf-unvr-rail { fill: #55595f; }
.rf-unvr-dot { fill: #ffffff; stroke: #c4c6ca; }
.rf-screen { fill: #0f1726; }
.rf-screen-ring { fill: none; stroke-width: 3; }
/* Ubiquiti UACC-Rack-Panel-Patch-Blank-24 (static/rack.js uaccPanelSvg) */
.ua-ear { fill: #6f7277; }
.ua-hole { fill: #15181c; }
.ua-face { fill: #8e9095; stroke: #6c6f74; }
.ua-lip { fill: #a6a8ad; }
.ua-open { fill: #17191d; }
.ua-bar { fill: #9a9ca1; }
.ua-keystone { fill: #101113; stroke: #2b2d31; }
.ua-keystone-hole { fill: #2f3236; }
.ua-num { fill: #2b2d31; font-size: 9px; font-family: Arial, Helvetica, sans-serif; }
.ua-label { fill: #1f2124; font-size: 8.5px; font-weight: 700; font-family: Arial, Helvetica, sans-serif; }
.ua-mark { fill: none; stroke: transparent; }
.rack-pp-ok .ua-mark { stroke: #00b860; stroke-width: 2.5; }
.rack-pp-bad .ua-mark { stroke: #e0312b; stroke-width: 3; }
.rack-pp-doc .ua-mark { stroke: #4c5662; stroke-width: 2; }
.rack-pp-port.rack-hl .ua-mark { fill: rgba(0,212,255,.25); stroke: #00b8e6; stroke-width: 3.5; }
+32 -5
View File
@@ -6,7 +6,7 @@
<meta name="theme-color" content="#030508">
<meta name="robots" content="noindex, nofollow">
<link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3E%3Crect width='16' height='16' rx='3' fill='%23030508'/%3E%3Cpath d='M8 2l5 3v6l-5 3-5-3V5z' fill='none' stroke='%2300e5ff' stroke-width='1.5'/%3E%3C/svg%3E">
<title>{% block title %}GANDALF{% endblock %} — GANDALF</title>
<title>{% block title %}Network Monitor{% endblock %} | GANDALF</title>
<link rel="preconnect" href="https://fonts.googleapis.com">
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
@@ -37,6 +37,15 @@
<a href="{{ url_for('index') }}"
class="lt-nav-drawer-link{% if request.endpoint == 'index' %} active{% endif %}"
{% if request.endpoint == 'index' %}aria-current="page"{% endif %}>Dashboard</a>
<a href="{{ url_for('events_page') }}"
class="lt-nav-drawer-link{% if request.endpoint == 'events_page' %} active{% endif %}"
{% if request.endpoint == 'events_page' %}aria-current="page"{% endif %}>History</a>
<a href="{{ url_for('cutsheet_page') }}"
class="lt-nav-drawer-link{% if request.endpoint == 'cutsheet_page' %} active{% endif %}"
{% if request.endpoint == 'cutsheet_page' %}aria-current="page"{% endif %}>Cutsheet</a>
<a href="{{ url_for('rack_page') }}"
class="lt-nav-drawer-link{% if request.endpoint == 'rack_page' %} active{% endif %}"
{% if request.endpoint == 'rack_page' %}aria-current="page"{% endif %}>Rack</a>
{% if user.groups and 'admin' in user.groups %}
<a href="{{ url_for('suppressions_page') }}"
class="lt-nav-drawer-link{% if request.endpoint == 'suppressions_page' %} active{% endif %}"
@@ -79,6 +88,21 @@
{% if request.endpoint == 'index' %}aria-current="page"{% endif %}>
Dashboard
</a>
<a href="{{ url_for('events_page') }}"
class="lt-nav-link{% if request.endpoint == 'events_page' %} active{% endif %}"
{% if request.endpoint == 'events_page' %}aria-current="page"{% endif %}>
History
</a>
<a href="{{ url_for('cutsheet_page') }}"
class="lt-nav-link{% if request.endpoint == 'cutsheet_page' %} active{% endif %}"
{% if request.endpoint == 'cutsheet_page' %}aria-current="page"{% endif %}>
Cutsheet
</a>
<a href="{{ url_for('rack_page') }}"
class="lt-nav-link{% if request.endpoint == 'rack_page' %} active{% endif %}"
{% if request.endpoint == 'rack_page' %}aria-current="page"{% endif %}>
Rack
</a>
{% if user.groups and 'admin' in user.groups %}
<a href="{{ url_for('suppressions_page') }}"
class="lt-nav-link{% if request.endpoint == 'suppressions_page' %} active{% endif %}"
@@ -103,7 +127,7 @@
<span class="lt-badge lt-badge-admin" aria-label="Administrator">ADMIN</span>
{% endif %}
<!-- Notification bell — shows active monitoring alerts -->
<!-- Notification bell: shows active monitoring alerts -->
<div class="lt-notif-dropdown-wrap" id="lt-notif-wrap">
<button type="button"
class="lt-btn lt-btn-ghost lt-btn-sm lt-notif-bell-btn"
@@ -163,7 +187,7 @@
{% block content %}{% endblock %}
</main>
<!-- FOOTER — context-sensitive per page -->
<!-- FOOTER: context-sensitive per page -->
<footer class="lt-footer" role="contentinfo">
<nav class="lt-footer-hints" aria-label="Keyboard shortcuts">
{% if request.endpoint == 'index' %}
@@ -182,7 +206,7 @@
<span>GANDALF &mdash; TDS v1.2</span>
</footer>
<!-- QUICK-SUPPRESS MODAL — available on all pages via [S] shortcut -->
<!-- QUICK-SUPPRESS MODAL: available on all pages via [S] shortcut -->
<div id="suppress-modal" class="lt-modal-overlay"
role="dialog" aria-modal="true" aria-labelledby="suppress-modal-title" aria-hidden="true">
<div class="lt-modal">
@@ -316,6 +340,9 @@
// Command palette
lt.cmdPalette.init([
{ id: 'nav-dashboard', group: 'Navigate', icon: '~', label: 'Dashboard', action: function() { window.location.href = '/'; } },
{ id: 'nav-history', group: 'Navigate', icon: '⏱', label: 'Alert History', action: function() { window.location.href = '/events'; } },
{ id: 'nav-cutsheet', group: 'Navigate', icon: '🔌', label: 'Cutsheet', action: function() { window.location.href = '/cutsheet'; } },
{ id: 'nav-rack', group: 'Navigate', icon: '🗄', label: 'Rack', action: function() { window.location.href = '/rack'; } },
{ id: 'nav-suppressions', group: 'Navigate', icon: '🔕', label: 'Suppressions', action: function() { window.location.href = '/suppressions'; } },
{ id: 'action-refresh', group: 'Actions', icon: '↻', label: 'Refresh Data', kbd: 'R', action: function() { lt.autoRefresh.now(); } },
{ id: 'action-suppress', group: 'Actions', icon: '🔕', label: 'New Suppression', kbd: 'S', action: function() { if (typeof openSuppressModal === 'function') openSuppressModal('host','',''); else window.location.href='/suppressions'; } },
@@ -395,7 +422,7 @@
});
})();
// ── Notification Bell — shows active monitoring alerts ────────────────
// ── Notification Bell: shows active monitoring alerts ────────────────
(function() {
const bell = document.getElementById('lt-notif-bell');
const panel = document.getElementById('lt-notif-panel');
+371
View File
@@ -0,0 +1,371 @@
{% extends "base.html" %}
{% block title %}Cutsheet{% endblock %}
{% block content %}
<div class="lt-page-header">
<div>
<h1 class="lt-page-title">Cutsheet</h1>
<p class="g-page-sub">Where every cable is meant to go, checked against what Gandalf sees on the network.</p>
</div>
<div class="cs-actions no-print">
{% if can_edit %}
<button type="button" class="lt-btn lt-btn-primary lt-btn-sm" data-action="new-cable">+ Cable</button>
<button type="button" class="lt-btn lt-btn-secondary lt-btn-sm" data-action="new-item">+ Panel / item</button>
<button type="button" class="lt-btn lt-btn-secondary lt-btn-sm" data-modal-open="cs-import-modal">Import CSV</button>
{% endif %}
<a class="lt-btn lt-btn-secondary lt-btn-sm" href="/api/cutsheet/cables.csv">Export CSV</a>
</div>
</div>
<div id="cs-summary" class="cs-summary" aria-live="polite"></div>
<section class="g-section" id="cs-cables-section">
<div class="g-section-header">
<h2 class="g-section-title">Cables</h2>
<span class="g-section-badge" id="cs-cable-count">0</span>
</div>
<div class="cs-filters no-print">
<input type="search" class="lt-input" id="cs-filter" placeholder="Filter by label, device, port or note" aria-label="Filter cables">
<select class="lt-select" id="cs-status-filter" aria-label="Filter by status">
<option value="">All statuses</option>
<option value="installed">Installed</option>
<option value="planned">Planned</option>
<option value="dark">Dark</option>
<option value="retired">Retired</option>
</select>
<label class="cs-check"><input type="checkbox" id="cs-problems-only"> Problems only</label>
</div>
<div id="cs-cables"></div>
</section>
<section class="g-section no-print" id="cs-suggest-section">
<div class="g-section-header">
<h2 class="g-section-title">Undocumented links</h2>
<span class="g-section-badge" id="cs-suggest-count">0</span>
</div>
<p class="cs-hint">Switch ports with a live link that no cable record mentions. Adding one pre-fills what Gandalf already knows; insert the patch panel hop if the cable runs through one.</p>
<div id="cs-suggestions"></div>
</section>
<section class="g-section" id="cs-panels-section">
<div class="g-section-header">
<h2 class="g-section-title">Patch panels</h2>
</div>
{% if can_edit %}
<div class="lt-frame cs-trace no-print" id="cs-trace">
<span class="lt-frame-bl">&#x255A;</span><span class="lt-frame-br">&#x255D;</span>
<div class="lt-section-header">Trace a cord</div>
<div class="lt-section-body">
<p class="cs-hint">Find which switch port a panel port's cord goes to: start, then unplug that cord at the panel.
Gandalf watches every switch port and shows the one that drops. Plug it back in afterwards. The device on it
loses its link for those few seconds.</p>
<div class="cs-trace-form">
<div class="lt-form-group">
<label class="lt-label" for="cs-trace-panel">Panel</label>
<select class="lt-select" id="cs-trace-panel"></select>
</div>
<div class="lt-form-group">
<label class="lt-label" for="cs-trace-port">Port</label>
<input class="lt-input" id="cs-trace-port" type="number" min="1" max="512" value="1">
</div>
<div class="lt-form-group cs-trace-buttons">
<button type="button" class="lt-btn lt-btn-primary lt-btn-sm" data-action="trace-start">Start</button>
<button type="button" class="lt-btn lt-btn-secondary lt-btn-sm" data-action="trace-stop" hidden>Stop</button>
</div>
</div>
<div id="cs-trace-status" class="cs-trace-status" aria-live="polite"></div>
</div>
</div>
{% endif %}
<div id="cs-panels"></div>
</section>
<section class="g-section" id="cs-labels-section">
<div class="g-section-header">
<h2 class="g-section-title">Labels to make</h2>
<span class="g-section-badge" id="cs-label-count">0</span>
<button type="button" class="lt-btn lt-btn-secondary lt-btn-sm no-print" data-action="print-labels">Print list</button>
</div>
<p class="cs-hint">Type these on the label maker. Cable IDs go on both ends of the cord; panel labels go on the port. Tick each one once it's stuck on.</p>
<div id="cs-labels"></div>
</section>
<section class="g-section" id="cs-rack-section">
<div class="g-section-header">
<h2 class="g-section-title">Rack</h2>
</div>
<div id="cs-rack"></div>
<p class="g-section-more"><a href="/rack">Open the rack drawing →</a></p>
</section>
<section class="g-section" id="cs-items-section">
<div class="g-section-header">
<h2 class="g-section-title">Inventory</h2>
<span class="g-section-badge" id="cs-item-count">0</span>
</div>
<p class="cs-hint">Things Gandalf can't discover: patch panels, wall jacks, shelves, and rack positions for devices.</p>
<div id="cs-items"></div>
</section>
<section class="g-section no-print" id="cs-history-section">
<div class="g-section-header">
<h2 class="g-section-title">History</h2>
</div>
<div id="cs-history"></div>
</section>
<datalist id="cs-device-list"></datalist>
<datalist id="cs-a-port-list"></datalist>
<datalist id="cs-b-port-list"></datalist>
{% if can_edit %}
<!-- Cable editor -->
<div id="cs-cable-modal" class="lt-modal-overlay" role="dialog" aria-modal="true" aria-labelledby="cs-cable-title" aria-hidden="true">
<div class="lt-modal cs-modal-wide">
<div class="lt-modal-header">
<h3 class="lt-modal-title" id="cs-cable-title">Cable</h3>
<button type="button" class="lt-modal-close" data-modal-close aria-label="Close">&#x2715;</button>
</div>
<form id="cs-cable-form" autocomplete="off">
<div class="lt-modal-body">
<input type="hidden" name="id">
<div class="form-row">
<div class="lt-form-group">
<label class="lt-label" for="cs-label">Cable ID</label>
<input class="lt-input" id="cs-label" name="label" maxlength="32">
<div class="lt-field-hint">Blank if the cable has no ID yet. Next free:
<span id="cs-next-label"></span> <button type="button" class="cs-link-btn" data-action="use-next-label">use</button></div>
</div>
<div class="lt-form-group">
<label class="lt-label" for="cs-status">Status</label>
<select class="lt-select" id="cs-status" name="status">
<option value="installed">Installed</option>
<option value="planned">Planned</option>
<option value="dark">Dark (run, not in use)</option>
<option value="retired">Retired</option>
</select>
</div>
</div>
<fieldset class="cs-end">
<legend>From</legend>
<div class="form-row">
<div class="lt-form-group">
<label class="lt-label" for="cs-a-device">Device or item <span class="required">*</span></label>
<input class="lt-input" id="cs-a-device" name="a_device" list="cs-device-list" required maxlength="100">
</div>
<div class="lt-form-group">
<label class="lt-label" for="cs-a-port">Port</label>
<input class="lt-input" id="cs-a-port" name="a_port" list="cs-a-port-list" maxlength="64">
</div>
<div class="lt-form-group cs-side" data-end="a">
<label class="lt-label" for="cs-a-side">Side</label>
<select class="lt-select" id="cs-a-side" name="a_side">
<option value="front">Front</option>
<option value="rear">Rear</option>
</select>
</div>
</div>
</fieldset>
<fieldset class="cs-end">
<legend>To</legend>
<div class="form-row">
<div class="lt-form-group">
<label class="lt-label" for="cs-b-device">Device or item</label>
<input class="lt-input" id="cs-b-device" name="b_device" list="cs-device-list" maxlength="100"
placeholder="blank = unterminated">
</div>
<div class="lt-form-group">
<label class="lt-label" for="cs-b-port">Port</label>
<input class="lt-input" id="cs-b-port" name="b_port" list="cs-b-port-list" maxlength="64">
</div>
<div class="lt-form-group cs-side" data-end="b">
<label class="lt-label" for="cs-b-side">Side</label>
<select class="lt-select" id="cs-b-side" name="b_side">
<option value="front">Front</option>
<option value="rear">Rear</option>
</select>
</div>
</div>
</fieldset>
<div class="form-row">
<div class="lt-form-group">
<label class="lt-label" for="cs-type">Type</label>
<select class="lt-select" id="cs-type" name="cable_type"></select>
</div>
<div class="lt-form-group">
<label class="lt-label" for="cs-length">Length (m)</label>
<input class="lt-input" id="cs-length" name="length_m" type="number" min="0.01" max="999" step="0.01">
</div>
<div class="lt-form-group">
<label class="lt-label" for="cs-color">Color</label>
<input class="lt-input" id="cs-color" name="color" maxlength="32">
</div>
</div>
<div class="lt-form-group">
<label class="lt-label" for="cs-notes">Notes</label>
<textarea class="lt-input" id="cs-notes" name="notes" rows="2" maxlength="2000"></textarea>
</div>
<label class="cs-check"><input type="checkbox" name="label_applied"> Label is on the cable</label>
</div>
<div class="lt-modal-footer">
<button type="button" class="lt-btn lt-btn-danger cs-delete" data-action="delete-cable">Delete</button>
<button type="button" class="lt-btn lt-btn-secondary" data-modal-close>Cancel</button>
<button type="submit" class="lt-btn lt-btn-primary">Save</button>
</div>
</form>
</div>
</div>
<!-- Item editor -->
<div id="cs-item-modal" class="lt-modal-overlay" role="dialog" aria-modal="true" aria-labelledby="cs-item-title" aria-hidden="true">
<div class="lt-modal">
<div class="lt-modal-header">
<h3 class="lt-modal-title" id="cs-item-title">Item</h3>
<button type="button" class="lt-modal-close" data-modal-close aria-label="Close">&#x2715;</button>
</div>
<form id="cs-item-form" autocomplete="off">
<div class="lt-modal-body">
<input type="hidden" name="id">
<div class="lt-form-group">
<label class="lt-label" for="cs-item-name">Name <span class="required">*</span></label>
<input class="lt-input" id="cs-item-name" name="name" required maxlength="100" list="cs-device-list">
</div>
<div class="lt-form-group">
<label class="lt-label" for="cs-item-device">Gandalf device</label>
<input class="lt-input" id="cs-item-device" name="device" maxlength="255" list="cs-known-devices"
placeholder="same as the name">
<datalist id="cs-known-devices"></datalist>
<div class="lt-field-hint">Which live device this is, when the name above is different (e.g. name "UDM-Pro", device "Dream Machine Pro"). Its faceplate, ports and status then show on the rack.</div>
</div>
<div class="form-row">
<div class="lt-form-group">
<label class="lt-label" for="cs-item-kind">Kind</label>
<select class="lt-select" id="cs-item-kind" name="kind">
<option value="patch_panel">Patch panel</option>
<option value="wall_jack">Wall jack</option>
<option value="device">Device</option>
<option value="shelf">Shelf</option>
<option value="other">Other</option>
</select>
</div>
<div class="lt-form-group">
<label class="lt-label" for="cs-item-ports">Ports</label>
<input class="lt-input" id="cs-item-ports" name="port_count" type="number" min="1" max="512">
</div>
</div>
<div class="form-row">
<div class="lt-form-group">
<label class="lt-label" for="cs-item-u">Rack unit (bottom)</label>
<input class="lt-input" id="cs-item-u" name="rack_u" type="number" min="1" max="60">
</div>
<div class="lt-form-group">
<label class="lt-label" for="cs-item-h">Height (U)</label>
<input class="lt-input" id="cs-item-h" name="rack_height" type="number" min="1" max="20">
</div>
</div>
<div class="lt-form-group">
<label class="lt-label" for="cs-item-chassis">Front drawing</label>
<select class="lt-select" id="cs-item-chassis" name="chassis"><option value="">Automatic (faceplate or plain plate)</option></select>
<div class="lt-field-hint">For gear Gandalf has no live faceplate for: the NVR, or a server's case.</div>
</div>
<div class="form-row">
<div class="lt-form-group">
<label class="lt-label" for="cs-item-rack">Rack</label>
<input class="lt-input" id="cs-item-rack" name="rack" maxlength="100" list="cs-rack-list" placeholder="first rack">
<datalist id="cs-rack-list"></datalist>
</div>
<div class="lt-form-group">
<label class="lt-label" for="cs-item-mount">Mounted</label>
<select class="lt-select" id="cs-item-mount" name="mount">
<option value="front">Front</option>
<option value="rear">Rear</option>
<option value="full">Full depth (both sides)</option>
</select>
</div>
</div>
<div class="form-row">
<div class="lt-form-group">
<label class="lt-label" for="cs-item-shelf">On shelf</label>
<select class="lt-select" id="cs-item-shelf" name="shelf"><option value="">Not on a shelf</option></select>
</div>
</div>
<div class="lt-field-hint cs-shelf-hint">Gear on a shelf (mini PCs, desk switches) takes its place and side from the shelf: leave its rack unit empty. On a 4-post rack a front and a rear item can share a unit; a full-depth one (a server) takes it on both sides.</div>
<div class="lt-form-group">
<label class="lt-label" for="cs-item-location">Location</label>
<input class="lt-input" id="cs-item-location" name="location" maxlength="255" placeholder="e.g. rack, office wall">
</div>
<div class="lt-form-group">
<label class="lt-label" for="cs-item-notes">Notes</label>
<textarea class="lt-input" id="cs-item-notes" name="notes" rows="2" maxlength="2000"></textarea>
</div>
</div>
<div class="lt-modal-footer">
<button type="button" class="lt-btn lt-btn-danger cs-delete" data-action="delete-item">Delete</button>
<button type="button" class="lt-btn lt-btn-secondary" data-modal-close>Cancel</button>
<button type="submit" class="lt-btn lt-btn-primary">Save</button>
</div>
</form>
</div>
</div>
<!-- Panel port label -->
<div id="cs-port-modal" class="lt-modal-overlay" role="dialog" aria-modal="true" aria-labelledby="cs-port-title" aria-hidden="true">
<div class="lt-modal">
<div class="lt-modal-header">
<h3 class="lt-modal-title" id="cs-port-title">Port label</h3>
<button type="button" class="lt-modal-close" data-modal-close aria-label="Close">&#x2715;</button>
</div>
<form id="cs-port-form" autocomplete="off">
<div class="lt-modal-body">
<input type="hidden" name="item_id">
<input type="hidden" name="port">
<div class="lt-form-group">
<label class="lt-label" for="cs-port-label">Label</label>
<input class="lt-input" id="cs-port-label" name="label" maxlength="64" placeholder="e.g. GUEST BR">
<div class="lt-field-hint">Usually where the port's rear run goes. Blank removes it.</div>
</div>
<label class="cs-check"><input type="checkbox" name="applied"> Label is on the panel</label>
</div>
<div class="lt-modal-footer">
<button type="button" class="lt-btn lt-btn-secondary" data-modal-close>Cancel</button>
<button type="submit" class="lt-btn lt-btn-primary">Save</button>
</div>
</form>
</div>
</div>
<!-- CSV import -->
<div id="cs-import-modal" class="lt-modal-overlay" role="dialog" aria-modal="true" aria-labelledby="cs-import-title" aria-hidden="true">
<div class="lt-modal cs-modal-wide">
<div class="lt-modal-header">
<h3 class="lt-modal-title" id="cs-import-title">Import cables from CSV</h3>
<button type="button" class="lt-modal-close" data-modal-close aria-label="Close">&#x2715;</button>
</div>
<form id="cs-import-form">
<div class="lt-modal-body">
<p class="cs-hint">Same columns as Export CSV. Rows with a cable ID that already exists update that cable; other rows are added. If any row is invalid, nothing is imported.</p>
<div class="lt-form-group">
<label class="lt-label" for="cs-import-file">CSV file</label>
<input class="lt-input" id="cs-import-file" type="file" accept=".csv,text/csv">
</div>
<div class="lt-form-group">
<label class="lt-label" for="cs-import-text">Or paste CSV</label>
<textarea class="lt-input cs-mono" id="cs-import-text" name="csv" rows="8"></textarea>
</div>
<div id="cs-import-errors" class="cs-errors" role="alert"></div>
</div>
<div class="lt-modal-footer">
<button type="button" class="lt-btn lt-btn-secondary" data-modal-close>Cancel</button>
<button type="button" class="lt-btn lt-btn-secondary" data-action="import-check">Check</button>
<button type="submit" class="lt-btn lt-btn-primary">Import</button>
</div>
</form>
</div>
</div>
{% endif %}
{% endblock %}
{% block scripts %}
<script>const CS_CAN_EDIT = {{ 'true' if can_edit else 'false' }};</script>
<script src="{{ url_for('static', filename='cutsheet.js') }}"></script>
{% endblock %}
+30 -2
View File
@@ -1,5 +1,5 @@
{% extends "base.html" %}
{% block title %}{{ device_name }} – GANDALF{% endblock %}
{% block title %}{{ device_name }}{% endblock %}
{% block content %}
<div class="lt-page-header">
@@ -46,10 +46,38 @@
</section>
{% include "_modem_panel.html" %}
{% if can_edit %}
<div id="inventory-modal" class="lt-modal-overlay" role="dialog" aria-modal="true" aria-labelledby="inventory-title" aria-hidden="true">
<div class="lt-modal">
<div class="lt-modal-header">
<h3 class="lt-modal-title" id="inventory-title">Inventory link</h3>
<button type="button" class="lt-modal-close" data-modal-close aria-label="Close">&#x2715;</button>
</div>
<form id="inventory-form">
<div class="lt-modal-body">
<p class="cs-hint">Open this device's record in the inventory and paste its address here. Leave it empty to remove the link.</p>
<div class="lt-form-group">
<label class="lt-label" for="inventory-url">Inventory record URL</label>
<input class="lt-input" id="inventory-url" name="url" type="url" inputmode="url" autocomplete="off"
placeholder="https://inventory.lotusguild.org/item/…">
</div>
<p class="cs-hint"><a id="inventory-search" href="#" target="_blank" rel="noopener">Search the inventory for this model ↗</a></p>
</div>
<div class="lt-modal-footer">
<button type="button" class="lt-btn lt-btn-secondary" data-modal-close>Cancel</button>
<button type="submit" class="lt-btn lt-btn-primary">Save</button>
</div>
</form>
</div>
</div>
{% endif %}
{% endblock %}
{% block scripts %}
<script>const DEVICE_NAME = {{ device_name | tojson }};</script>
<script>const DEVICE_NAME = {{ device_name | tojson }};
const CAN_EDIT = {{ 'true' if can_edit else 'false' }};</script>
<script src="{{ url_for('static', filename='faceplates.js') }}"></script>
<script src="{{ url_for('static', filename='port-inspector.js') }}"></script>
<script src="{{ url_for('static', filename='device.js') }}"></script>
{% endblock %}
+66
View File
@@ -0,0 +1,66 @@
{% extends "base.html" %}
{% block title %}Alert History{% endblock %}
{% block content %}
<div class="lt-page-header">
<div>
<h1 class="lt-page-title">Alert History</h1>
<p class="g-page-sub">Every alert Gandalf raised, including the ones that cleared on their own. Resolved alerts are kept 90 days.</p>
</div>
</div>
<form class="cs-filters ev-filters" id="ev-filters" role="search" aria-label="Filter alert history">
<input type="search" class="lt-input" id="ev-target" name="target" placeholder="Device, host, port or interface"
aria-label="Filter by device" autocomplete="off">
<select class="lt-select" id="ev-range" name="range" aria-label="Time range">
<option value="24h">Last 24 hours</option>
<option value="7d" selected>Last 7 days</option>
<option value="30d">Last 30 days</option>
<option value="90d">Last 90 days</option>
</select>
<select class="lt-select" id="ev-type" name="type" aria-label="Alert type">
<option value="">All alert types</option>
</select>
<select class="lt-select" id="ev-severity" name="severity" aria-label="Severity">
<option value="">All severities</option>
<option value="critical">Critical</option>
<option value="warning">Warning</option>
<option value="info">Info</option>
</select>
<select class="lt-select" id="ev-status" name="status" aria-label="State">
<option value="all">Open and cleared</option>
<option value="active">Open now</option>
<option value="resolved">Cleared</option>
</select>
<button type="button" class="lt-btn lt-btn-secondary lt-btn-sm" id="ev-clear" hidden>Clear filters</button>
</form>
<div id="ev-summary" class="cs-summary" aria-live="polite"></div>
<section class="g-section" id="ev-flappers-section" hidden>
<div class="g-section-header">
<h2 class="g-section-title">Recurring</h2>
</div>
<p class="cs-hint">The same alert on the same target more than once in this range. Something that keeps coming back usually has one cause worth finding.</p>
<div class="lt-frame">
<span class="lt-frame-bl">&#x255A;</span><span class="lt-frame-br">&#x255D;</span>
<div id="ev-flappers"></div>
</div>
</section>
<section class="g-section">
<div class="g-section-header">
<h2 class="g-section-title">Alerts</h2>
<span class="g-section-badge" id="ev-count">0</span>
</div>
<div class="lt-frame">
<span class="lt-frame-bl">&#x255A;</span><span class="lt-frame-br">&#x255D;</span>
<div id="ev-table"><div class="lt-empty-state lt-empty-state--sm"><div class="lt-empty-state-title">Loading…</div></div></div>
</div>
<div class="ev-pager" id="ev-pager"></div>
</section>
{% endblock %}
{% block scripts %}
<script src="{{ url_for('static', filename='events.js') }}"></script>
{% endblock %}
+14 -14
View File
@@ -1,5 +1,5 @@
{% extends "base.html" %}
{% block title %}Dashboard – GANDALF{% endblock %}
{% block title %}Dashboard{% endblock %}
{% block content %}
@@ -103,7 +103,7 @@
<div id="events-table-wrap">
{% if events %}
{% if total_active is defined and total_active > events|length %}
<div class="pagination-notice">Showing {{ events|length }} of {{ total_active }} active alerts — use the search box to filter, or <a href="/api/events?limit=1000" target="_blank" rel="noopener">export all as JSON</a></div>
<div class="pagination-notice">Showing {{ events|length }} of {{ total_active }} active alerts. Use the search box to filter, or <a href="/api/events?limit=1000" target="_blank" rel="noopener">export all as JSON</a></div>
{% endif %}
<div class="lt-table-wrap">
<table class="lt-table" id="events-table">
@@ -132,7 +132,7 @@
</td>
<td>{{ e.event_type | replace('_', ' ') }}</td>
<td><strong>{{ e.target_name }}</strong></td>
<td>{{ e.target_detail or '–' }}</td>
<td>{{ e.target_detail or '-' }}</td>
<td class="desc-cell" title="{{ e.description | e }}">{{ e.description | truncate(60) }}</td>
<td class="ts-cell" title="{{ e.first_seen }}">
<span class="event-age" data-ts="{{ e.first_seen }}">{{ e.first_seen }}</span>
@@ -145,7 +145,7 @@
{% if e.ticket_id %}
<a href="{{ config.ticket_api.web_url }}{{ e.ticket_id }}" target="_blank"
class="ticket-link">#{{ e.ticket_id }}</a>
{% else %}–{% endif %}
{% else %}-{% endif %}
</td>
<td>
<button class="lt-btn lt-btn-ghost lt-btn-sm btn-suppress"
@@ -335,7 +335,7 @@
<span class="topo-v2-icon">◈</span>
<span class="topo-v2-label">BGW320</span>
<span class="topo-v2-sub">AT&amp;T Gateway</span>
<span class="topo-v2-sub" id="topo-modem-rx">Rx –</span>
<span class="topo-v2-sub" id="topo-modem-rx">Rx -</span>
</div>
</div>
@@ -346,7 +346,7 @@
</div>
<!-- ══════════════════════════════════════════════════════════════
TIER 2: Router – UDM-Pro
TIER 2: Router, UDM-Pro
══════════════════════════════════════════════════════════ -->
<div class="topo-tier">
<div class="topo-v2-node topo-v2-router">
@@ -401,7 +401,7 @@
</div>
<!-- ══════════════════════════════════════════════════════════════
TIER 4 connecting bus – two rails (10G green + 1G amber dashed)
TIER 4 connecting bus: two rails (10G green + 1G amber dashed)
showing dual-homing for all 6 servers
══════════════════════════════════════════════════════════ -->
<div class="topo-bus-section">
@@ -421,8 +421,8 @@
<!-- ── Host nodes with drop wires ── -->
<div class="topo-v2-hosts">
{%- set all_defs = [
('compute-storage-gpu-01', 'csg-01', 'RU4–12', 'Ceph · VLAN90', False),
('compute-storage-01', 'cs-01', 'RU14–17', 'Ceph · VLAN90', False),
('compute-storage-gpu-01', 'csg-01', 'RU4-12', 'Ceph · VLAN90', False),
('compute-storage-01', 'cs-01', 'RU14-17', 'Ceph · VLAN90', False),
('storage-01', 'sto-01', 'rack', 'Ceph · VLAN90', False),
('monitor-01', 'mon-01', 'ZimaBoard', 'mgmt', False),
('monitor-02', 'mon-02', 'ZimaBoard', 'mgmt', False),
@@ -443,7 +443,7 @@
<span class="topo-v2-label">{{ hlabel }}</span>
<span class="topo-v2-sub">{{ hsub }}</span>
<span class="topo-v2-vlan">{{ hvlan }}</span>
<span class="topo-badge topo-badge-{{ st }}">{{ st if st != 'unknown' else '–' }}</span>
<span class="topo-badge topo-badge-{{ st }}">{{ st if st != 'unknown' else '-' }}</span>
</div>
</div>
{%- endfor -%}
@@ -487,7 +487,7 @@
&nbsp;·&nbsp;
<span class="lt-badge badge-resolved">{{ e.severity }}</span>
&nbsp;·&nbsp; duration
<span class="event-duration" data-first="{{ e.first_seen }}" data-resolved="{{ e.resolved_at }}">–</span>
<span class="event-duration" data-first="{{ e.first_seen }}" data-resolved="{{ e.resolved_at }}">-</span>
</div>
</div>
{% endfor %}
@@ -547,9 +547,9 @@
// ── Event duration (resolved_at - first_seen) ──────────────────
function fmtDuration(firstTs, resolvedTs) {
if (!firstTs || !resolvedTs) return '–';
if (!firstTs || !resolvedTs) return '-';
const secs = Math.floor((new Date(_toIso(resolvedTs)) - new Date(_toIso(firstTs))) / 1000);
if (secs < 0) return '–';
if (secs < 0) return '-';
if (secs < 60) return `${secs}s`;
if (secs < 3600) return `${Math.floor(secs/60)}m`;
if (secs < 86400) return `${Math.floor(secs/3600)}h ${Math.floor((secs%3600)/60)}m`;
@@ -602,7 +602,7 @@
if (node) window.location.href = deviceUrl(node.dataset.host);
});
// Stat card clicks — filter events table by severity
// Stat card clicks: filter events table by severity
document.querySelectorAll('.lt-stat-card[data-stat-filter]').forEach(card => {
card.addEventListener('click', () => {
const sev = card.dataset.statFilter;
+89
View File
@@ -0,0 +1,89 @@
{% extends "base.html" %}
{% block title %}Rack{% endblock %}
{% block content %}
<div class="lt-page-header">
<div>
<h1 class="lt-page-title">Rack</h1>
<p class="g-page-sub">The rack front, drawn from the rack units on the cutsheet with live port state. Hover a port to light up every port on the same cable run; click it to open the port or the cable.</p>
</div>
<div class="cs-actions no-print">
<button type="button" class="lt-btn lt-btn-secondary lt-btn-sm" data-export="svg">Download SVG</button>
<button type="button" class="lt-btn lt-btn-secondary lt-btn-sm" data-export="png">Download PNG</button>
{% if can_edit %}
<button type="button" class="lt-btn lt-btn-secondary lt-btn-sm" data-action="rack-settings">Rack settings</button>
<button type="button" class="lt-btn lt-btn-secondary lt-btn-sm" data-action="add-rack">+ Rack</button>
<a class="lt-btn lt-btn-secondary lt-btn-sm" href="/cutsheet#cs-items-section">Edit positions</a>
{% endif %}
</div>
</div>
<div class="rack-bar">
<div class="rack-tabs" id="rack-tabs" role="tablist" aria-label="Racks" hidden></div>
<div class="rack-face" role="group" aria-label="Rack side">
<button type="button" class="rack-face-btn active" data-face="front" aria-pressed="true">Front</button>
<button type="button" class="rack-face-btn" data-face="rear" aria-pressed="false">Rear</button>
</div>
</div>
<div class="rack-warnings" id="rack-warnings" role="alert" hidden></div>
<section class="g-section">
<div class="g-section-header">
<h2 class="g-section-title" id="rack-title">Front</h2>
<span class="g-section-badge" id="rack-count">0</span>
</div>
<p class="rack-readout" id="rack-readout" aria-live="polite"></p>
<div class="rack-legend" aria-hidden="true">
<span><i class="rack-key rack-key-ok"></i>matches cutsheet</span>
<span><i class="rack-key rack-key-bad"></i>mismatch</span>
<span><i class="rack-key rack-key-doc"></i>documented, unconfirmed</span>
<label class="rack-toggle"><input type="checkbox" id="rack-show-empty"> Show empty units</label>
</div>
<div class="rack" id="rack"><div class="link-loading">Loading rack</div></div>
<p class="cs-hint rack-unplaced" id="rack-unplaced"></p>
</section>
{% if can_edit %}
<div id="rack-modal" class="lt-modal-overlay" role="dialog" aria-modal="true" aria-labelledby="rack-modal-title" aria-hidden="true">
<div class="lt-modal">
<div class="lt-modal-header">
<h3 class="lt-modal-title" id="rack-modal-title">Rack settings</h3>
<button type="button" class="lt-modal-close" data-modal-close aria-label="Close">&#x2715;</button>
</div>
<form id="rack-form" autocomplete="off">
<div class="lt-modal-body">
<input type="hidden" name="id">
<input type="hidden" name="previous">
<div class="form-row">
<div class="lt-form-group">
<label class="lt-label" for="rack-name">Name <span class="required">*</span></label>
<input class="lt-input" id="rack-name" name="name" required maxlength="100" placeholder="e.g. StarTech 25U">
</div>
<div class="lt-form-group">
<label class="lt-label" for="rack-units">Height (U) <span class="required">*</span></label>
<input class="lt-input" id="rack-units" name="units" type="number" min="1" max="60" required>
</div>
</div>
<div class="lt-form-group">
<label class="lt-label" for="rack-notes">Notes</label>
<textarea class="lt-input" id="rack-notes" name="notes" rows="2" maxlength="2000" placeholder="model, location, depth"></textarea>
</div>
<p class="cs-hint">Renaming a rack moves its items with it. A rack can be deleted once it is empty.</p>
</div>
<div class="lt-modal-footer">
<button type="button" class="lt-btn lt-btn-danger" data-action="delete-rack">Delete</button>
<button type="button" class="lt-btn lt-btn-secondary" data-modal-close>Cancel</button>
<button type="submit" class="lt-btn lt-btn-primary">Save</button>
</div>
</form>
</div>
</div>
{% endif %}
{% endblock %}
{% block scripts %}
<script>const RACK_CAN_EDIT = {{ 'true' if can_edit else 'false' }};</script>
<script src="{{ url_for('static', filename='faceplates.js') }}"></script>
<script src="{{ url_for('static', filename='fronts.js') }}"></script>
<script src="{{ url_for('static', filename='rack.js') }}"></script>
{% endblock %}
+4 -4
View File
@@ -1,5 +1,5 @@
{% extends "base.html" %}
{% block title %}Suppressions – GANDALF{% endblock %}
{% block title %}Suppressions{% endblock %}
{% block content %}
@@ -104,7 +104,7 @@
{%- set _sup_badge = {'host':'badge-warning','interface':'badge-info','unifi_device':'badge-purple','all':'badge-critical'} -%}
<td><span class="lt-badge {{ _sup_badge.get(s.target_type, 'badge-neutral') }}">{{ s.target_type }}</span></td>
<td>{{ s.target_name or 'all' }}</td>
<td>{{ s.target_detail or '–' }}</td>
<td>{{ s.target_detail or '-' }}</td>
<td>{{ s.reason }}</td>
<td>{{ s.suppressed_by }}</td>
<td class="ts-cell">{{ s.created_at }}</td>
@@ -154,7 +154,7 @@
<tr class="{% if not s.active %}row-resolved{% endif %}">
<td>{{ s.target_type }}</td>
<td>{{ s.target_name or 'all' }}</td>
<td>{{ s.target_detail or '–' }}</td>
<td>{{ s.target_detail or '-' }}</td>
<td>{{ s.reason }}</td>
<td>{{ s.suppressed_by }}</td>
<td class="ts-cell">{{ s.created_at }}</td>
@@ -243,7 +243,7 @@
<tr id="sup-row-${s.id}">
<td><span class="lt-badge ${SUP_BADGE[s.target_type] || 'badge-neutral'}">${lt.escHtml(s.target_type)}</span></td>
<td>${lt.escHtml(s.target_name || 'all')}</td>
<td>${lt.escHtml(s.target_detail || '–')}</td>
<td>${lt.escHtml(s.target_detail || '-')}</td>
<td>${lt.escHtml(s.reason)}</td>
<td>${lt.escHtml(s.suppressed_by)}</td>
<td class="ts-cell">${lt.escHtml(s.created_at || '')}</td>
+444 -2
View File
@@ -10,7 +10,10 @@ sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
import app as gandalf # noqa: E402
AUTH = {'Remote-User': 'jared', 'Remote-Name': 'Jared V', 'Remote-Groups': 'admin'}
PROXY = '10.0.0.27'
# What the local nginx forwards for a request that came through the Authelia proxy
AUTH = {'Remote-User': 'jared', 'Remote-Name': 'Jared V', 'Remote-Groups': 'admin', 'X-Real-IP': PROXY}
CONFIG = {'auth': {'allowed_groups': ['admin'], 'trusted_proxies': [PROXY]}, 'ticket_api': {}}
STATE = {
'network_snapshot': json.dumps({
'hosts': {'large1': {'ip': '10.0.0.2', 'status': 'up', 'source': 'prometheus', 'interfaces': {'eth0': 'up'}}},
@@ -32,10 +35,54 @@ def client():
db.count_active_events.return_value = 0
db.get_status_summary.return_value = {'critical': 0, 'warning': 0, 'info': 0, 'resolved_24h': 0}
db.check_suppressed.return_value = False
with patch.object(gandalf, '_cfg', {'auth': {'allowed_groups': ['admin']}, 'ticket_api': {}}):
db.get_device_link.return_value = ''
db.cutsheet_racks.return_value = []
with patch.object(gandalf, '_cfg', CONFIG):
yield gandalf.app.test_client()
class TestIdentityHeaderTrust:
def test_proxy_identity_is_accepted(self, client):
assert client.get('/api/devices', headers=AUTH).status_code == 200
def test_lan_client_through_nginx_cannot_claim_a_user(self, client):
spoofed = dict(AUTH, **{'X-Real-IP': '10.0.0.99'})
assert client.get('/api/devices', headers=spoofed).status_code == 401
def test_loopback_without_nginx_source_is_untrusted(self, client):
spoofed = {k: v for k, v in AUTH.items() if k != 'X-Real-IP'}
assert client.get('/api/devices', headers=spoofed).status_code == 401
def test_direct_peer_cannot_borrow_the_proxy_address(self, client):
resp = client.get('/api/devices', headers=AUTH, environ_base={'REMOTE_ADDR': '10.0.0.99'})
assert resp.status_code == 401
def test_proxy_connecting_directly_is_trusted(self, client):
resp = client.get('/api/devices', headers=AUTH, environ_base={'REMOTE_ADDR': PROXY})
assert resp.status_code == 200
def test_fails_closed_without_trusted_proxies(self, client):
with patch.object(gandalf, '_cfg', {'auth': {'allowed_groups': ['admin']}}):
assert client.get('/api/devices', headers=AUTH).status_code == 401
def test_cidr_entries_and_bad_entries(self, client):
cfg = {'auth': {'allowed_groups': ['admin'], 'trusted_proxies': ['not-an-ip', '10.0.0.0/24']}}
with patch.object(gandalf, '_cfg', cfg):
assert client.get('/api/devices', headers=AUTH).status_code == 200
def test_garbage_source_header_is_untrusted(self, client):
assert client.get('/api/devices', headers=dict(AUTH, **{'X-Real-IP': 'not-an-ip'})).status_code == 401
def test_rejection_is_logged(self, client, caplog):
client.get('/api/devices', headers=dict(AUTH, **{'X-Real-IP': '10.0.0.99'}))
assert "untrusted source '10.0.0.99'" in caplog.text
def test_avatar_ignores_untrusted_identity(self, client):
with patch.object(gandalf, '_config', return_value=dict(CONFIG, ldap={'host': 'h', 'bind_dn': 'b'})):
resp = client.get('/api/avatar', headers=dict(AUTH, **{'X-Real-IP': '10.0.0.99'}))
assert resp.status_code == 401
class TestPagesAndNav:
def test_home_has_search_and_no_link_debug(self, client):
html = client.get('/', headers=AUTH).get_data(as_text=True)
@@ -70,6 +117,10 @@ class TestPagesAndNav:
html = client.get('/device/large1', headers=AUTH).get_data(as_text=True)
assert 'port-inspector.js' in html and 'id="inspector-panel"' in html
def test_faceplates_load_before_the_port_inspector(self, client):
html = client.get('/device/large1', headers=AUTH).get_data(as_text=True)
assert html.index('faceplates.js') < html.index('port-inspector.js')
def test_link_data_api_remains(self, client):
assert client.get('/api/links', headers=AUTH).status_code == 200
@@ -122,3 +173,394 @@ class TestDiagnoseWithResolvedNeighbor:
finally:
STATE['link_stats'] = saved
assert resp.status_code == 200 and resp.get_json()['job_id']
CUTSHEET = {
'items': [{'id': 1, 'name': 'PP1', 'kind': 'patch_panel', 'port_count': 24, 'location': 'rack',
'rack_u': 25, 'rack_height': 1, 'notes': ''}],
'cables': [{'id': 7, 'label': 'C07', 'a_device': 'USW Flex', 'a_port': '2', 'a_side': '',
'b_device': 'PP1', 'b_port': '5', 'b_side': 'front', 'status': 'installed',
'cable_type': 'Cat6', 'length_m': None, 'color': '', 'notes': '', 'label_applied': False}],
'port_labels': [{'item_id': 1, 'item_name': 'PP1', 'port': '5', 'label': 'OFFICE', 'applied': False}],
}
USER = dict(AUTH, **{'Remote-Groups': 'staff'})
@pytest.fixture
def cs_client(client):
gandalf._cutsheet_schema_ready = True
db = gandalf.db
db.cutsheet_load.side_effect = lambda: json.loads(json.dumps(CUTSHEET))
db.cutsheet_history.return_value = []
db.cutsheet_create_cable.return_value = 8
db.CutsheetConflict = type('CutsheetConflict', (Exception,), {})
with patch.object(gandalf, '_cfg', dict(CONFIG, auth={'allowed_groups': ['admin', 'staff'],
'trusted_proxies': [PROXY]})):
yield client, db
class TestCutsheetApi:
def test_page_and_view(self, cs_client):
client, _ = cs_client
assert client.get('/cutsheet', headers=AUTH).status_code == 200
view = client.get('/api/cutsheet', headers=AUTH).get_json()
c = view['cables'][0]
assert c['b_text'] == 'PP1 port 5 (front)' and c['verdict'] in view['verdicts']
assert view['next_label'] == 'C01'
assert view['labels']['cables'][0]['text'] == 'C07'
assert any(d['name'] == 'PP1' for d in view['catalog'])
def test_create_cable(self, cs_client):
client, db = cs_client
resp = client.post('/api/cutsheet/cables', headers=AUTH,
json={'a_device': 'USW Flex', 'a_port': '3', 'b_device': 'PP1', 'b_port': '6',
'b_side': 'front', 'label': 'C08'})
assert resp.status_code == 200 and resp.get_json()['id'] == 8
saved, user = db.cutsheet_create_cable.call_args.args
assert saved['b_side'] == 'front' and user == 'jared'
def test_viewers_cannot_edit(self, cs_client):
client, db = cs_client
assert client.get('/api/cutsheet', headers=USER).status_code == 200
resp = client.post('/api/cutsheet/cables', headers=USER, json={'a_device': 'x'})
assert resp.status_code == 403 and not db.cutsheet_create_cable.called
def test_writes_require_json(self, cs_client):
client, db = cs_client
resp = client.post('/api/cutsheet/cables', headers=AUTH, data='a_device=x',
content_type='application/x-www-form-urlencoded')
assert resp.status_code == 400 and not db.cutsheet_create_cable.called
def test_validation_error_is_400(self, cs_client):
client, _ = cs_client
resp = client.post('/api/cutsheet/cables', headers=AUTH, json={'a_device': 'PP1', 'a_port': '3'})
assert resp.status_code == 400 and 'front or rear' in resp.get_json()['error']
def test_conflict_is_409(self, cs_client):
client, db = cs_client
db.cutsheet_create_item.side_effect = db.CutsheetConflict('Another item already has that name')
resp = client.post('/api/cutsheet/items', headers=AUTH, json={'name': 'PP1', 'kind': 'shelf'})
assert resp.status_code == 409 and 'already' in resp.get_json()['error']
def test_missing_records_are_404(self, cs_client):
client, db = cs_client
db.cutsheet_delete_cable.return_value = False
assert client.delete('/api/cutsheet/cables/99', headers=AUTH).status_code == 404
def test_port_label(self, cs_client):
client, db = cs_client
resp = client.put('/api/cutsheet/items/1/ports/5', headers=AUTH, json={'label': 'GUEST BR', 'applied': True})
assert resp.status_code == 200
assert db.cutsheet_set_port_label.call_args.args == (1, '5', 'GUEST BR', True, 'jared')
def test_csv_export_and_all_or_nothing_import(self, cs_client):
client, db = cs_client
text = client.get('/api/cutsheet/cables.csv', headers=AUTH).get_data(as_text=True)
assert text.startswith('label,a_device') and 'C07' in text
bad = client.post('/api/cutsheet/import', headers=AUTH, json={'csv': text + 'C09,PP1,99,front\n'})
assert bad.status_code == 400 and bad.get_json()['errors'] and not db.cutsheet_import_cables.called
dry = client.post('/api/cutsheet/import', headers=AUTH, json={'csv': text, 'dry_run': True})
assert dry.get_json()['rows'] == 1 and not db.cutsheet_import_cables.called
db.cutsheet_import_cables.return_value = {'added': 0, 'updated': 1}
done = client.post('/api/cutsheet/import', headers=AUTH, json={'csv': text})
assert done.get_json()['updated'] == 1
def test_device_page_and_search_include_the_cutsheet(self, cs_client):
client, _ = cs_client
d = client.get('/api/device/USW%20Flex', headers=AUTH).get_json()
assert d['cutsheet'][0]['label'] == 'C07' and d['cutsheet'][0]['port'] == '2'
found = client.get('/api/devices', headers=AUTH).get_json()['devices']
by_name = {x['name']: x for x in found}
assert by_name['C07']['url'] == '/cutsheet#cable-7'
assert by_name['PP1']['url'] == '/cutsheet#item-1'
def test_device_page_survives_a_cutsheet_failure(self, cs_client):
client, db = cs_client
db.cutsheet_load.side_effect = RuntimeError('db down')
d = client.get('/api/device/USW%20Flex', headers=AUTH).get_json()
assert d['cutsheet'] == []
class TestCutsheetLivePorts:
def _fake(self, result):
class Fake:
calls = 0
def __init__(self, cfg):
pass
def get_switch_ports(self):
Fake.calls += 1
return result
return Fake
def test_reads_unifi_and_caches_briefly(self, cs_client):
client, _ = cs_client
fake = self._fake({'sw': {'ports': {'Office TV': {'port_idx': 13, 'up': True},
'Port 14': {'port_idx': 14, 'up': False}}}})
gandalf._live_ports_cache.update(at=0.0, data=None, client=None)
with patch.object(gandalf, 'UnifiClient', fake), \
patch.dict(gandalf._cfg, {'unifi': {'controller': 'https://u', 'api_key': 'k'}}):
first = client.get('/api/cutsheet/live-ports', headers=AUTH).get_json()
client.get('/api/cutsheet/live-ports', headers=AUTH)
assert first['switches'] == {'sw': {'13': {'up': True, 'name': 'Office TV'},
'14': {'up': False, 'name': 'Port 14'}}}
assert fake.calls == 1
def test_controller_failure_is_502_and_not_cached(self, cs_client):
client, _ = cs_client
gandalf._live_ports_cache.update(at=0.0, data=None, client=None)
with patch.object(gandalf, 'UnifiClient', self._fake(None)), \
patch.dict(gandalf._cfg, {'unifi': {'controller': 'https://u', 'api_key': 'k'}}):
assert client.get('/api/cutsheet/live-ports', headers=AUTH).status_code == 502
assert gandalf._live_ports_cache['data'] is None
def test_admin_only(self, cs_client):
client, _ = cs_client
assert client.get('/api/cutsheet/live-ports', headers=USER).status_code == 403
class TestAlertHistory:
HISTORY = {'events': [], 'total': 0, 'by_type': {}}
def _db(self):
db = gandalf.db
db.get_events_history.return_value = dict(self.HISTORY)
db.get_flappers.return_value = []
db.get_event_types.return_value = ['host_unreachable']
return db
def test_page_and_nav(self, client):
html = client.get('/events', headers=AUTH).get_data(as_text=True)
assert 'Alert History' in html and 'events.js' in html
assert 'href="/events"' in client.get('/', headers=AUTH).get_data(as_text=True)
def test_defaults_to_seven_days(self, client):
db = self._db()
data = client.get('/api/events/history', headers=AUTH).get_json()
assert db.get_events_history.call_args.args == (168, '', '', '', 'all')
assert data['types'] == ['host_unreachable'] and data['page_size'] == 100
def test_filters_are_passed_through(self, client):
db = self._db()
client.get('/api/events/history?range=90d&type=interface_down&target=+large1+&severity=critical'
'&status=resolved&offset=200', headers=AUTH)
assert db.get_events_history.call_args.args == (2160, 'interface_down', 'large1', 'critical', 'resolved')
assert db.get_events_history.call_args.kwargs == {'limit': 100, 'offset': 200}
assert db.get_flappers.call_args.args == (2160, 'interface_down', 'large1', 'critical')
@pytest.mark.parametrize('query', ['range=1y', 'severity=bad', 'status=open', 'offset=x'])
def test_bad_filters_are_rejected(self, client, query):
self._db()
assert client.get(f'/api/events/history?{query}', headers=AUTH).status_code == 400
def test_needs_login(self, client):
assert client.get('/api/events/history').status_code == 401
class TestHealth:
def _health(self, client, age_s, poll=120):
from datetime import datetime, timedelta, timezone
stamp = (datetime.now(timezone.utc) - timedelta(seconds=age_s)).strftime('%Y-%m-%d %H:%M:%S UTC')
gandalf.db.get_state.side_effect = lambda key, default=None: stamp if key == 'last_check' else default
with patch.object(gandalf, '_cfg', dict(CONFIG, monitor={'poll_interval': poll})):
return client.get('/health')
def test_recent_check_is_healthy(self, client):
resp = self._health(client, 150)
assert resp.status_code == 200 and resp.get_json()['checks']['monitor'] == 'ok'
def test_stalled_monitor_fails_after_ten_minutes(self, client):
resp = self._health(client, 660)
assert resp.status_code == 503
assert resp.get_json()['checks'] == {'db': 'ok', 'monitor': 'stale', 'monitor_age_s': 660}
def test_limit_follows_a_long_poll_interval(self, client):
assert self._health(client, 1000, poll=300).status_code == 200
assert self._health(client, 1600, poll=300).status_code == 503
class TestPageTitles:
@pytest.mark.parametrize('path,title', [('/', 'Dashboard | GANDALF'), ('/events', 'Alert History | GANDALF'),
('/cutsheet', 'Cutsheet | GANDALF')])
def test_name_appears_once(self, client, path, title):
gandalf._cutsheet_schema_ready = True
html = client.get(path, headers=AUTH).get_data(as_text=True)
assert f'<title>{title}</title>' in html
class TestInventoryLinks:
def _put(self, client, url, headers=AUTH, name='USW Flex'):
gandalf._cutsheet_schema_ready = True
return client.put(f'/api/device/{name}/inventory', json={'url': url}, headers=headers)
def test_device_api_has_link_and_search(self, client):
gandalf._cutsheet_schema_ready = True
gandalf.db.get_device_link.return_value = 'https://inventory.lotusguild.org/item/abc'
inv = client.get('/api/device/USW Flex', headers=AUTH).get_json()['inventory']
assert inv == {'url': 'https://inventory.lotusguild.org/item/abc',
'search_url': 'https://inventory.lotusguild.org/items?q=USF5P'}
def test_admin_sets_and_clears(self, client):
assert self._put(client, ' https://inventory.lotusguild.org/item/abc ').status_code == 200
gandalf.db.set_device_link.assert_called_with('USW Flex', 'https://inventory.lotusguild.org/item/abc', 'jared')
assert self._put(client, '').status_code == 200
gandalf.db.set_device_link.assert_called_with('USW Flex', '', 'jared')
@pytest.mark.parametrize('url', ['http://inventory.lotusguild.org/item/a', 'https://evil.example/item/a',
'https://inventory.lotusguild.org.evil.example/x', 'javascript:alert(1)',
'https://user:pw@inventory.lotusguild.org/x',
'https://inventory.lotusguild.org/' + 'a' * 600])
def test_only_inventory_links_are_accepted(self, client, url):
assert self._put(client, url).status_code == 400
assert not gandalf.db.set_device_link.called
def test_configured_host(self, client):
cfg = dict(CONFIG, inventory={'base_url': 'https://homebox.example'})
with patch.object(gandalf, '_cfg', cfg):
assert self._put(client, 'https://homebox.example/item/1').status_code == 200
assert self._put(client, 'https://inventory.lotusguild.org/item/1').status_code == 400
def test_needs_admin_and_json(self, client):
user = dict(AUTH, **{'Remote-Groups': 'staff'})
with patch.object(gandalf, '_cfg', dict(CONFIG, auth=dict(CONFIG['auth'], allowed_groups=['admin', 'staff']))):
assert self._put(client, 'https://inventory.lotusguild.org/x', headers=user).status_code == 403
gandalf._cutsheet_schema_ready = True
resp = client.put('/api/device/USW Flex/inventory', data='url=x', headers=AUTH)
assert resp.status_code == 400
class TestRackApi:
def test_rack_combines_items_switches_and_marks(self, client):
gandalf._cutsheet_schema_ready = True
db = gandalf.db
db.cutsheet_load.return_value = {
'items': [
{'id': 1, 'name': 'USW Flex', 'kind': 'device', 'port_count': None, 'rack_u': 20, 'rack_height': 1,
'location': '', 'notes': ''},
{'id': 2, 'name': 'PP1', 'kind': 'patch_panel', 'port_count': 24, 'rack_u': 21, 'rack_height': 1,
'location': '', 'notes': ''},
{'id': 3, 'name': 'Shelf', 'kind': 'shelf', 'port_count': None, 'rack_u': 20, 'rack_height': 1,
'location': '', 'notes': ''},
{'id': 4, 'name': 'Loose', 'kind': 'other', 'port_count': None, 'rack_u': None, 'rack_height': None,
'location': '', 'notes': ''},
],
'cables': [{'id': 7, 'label': 'C07', 'a_device': 'USW Flex', 'a_port': '2', 'a_side': '',
'b_device': 'PP1', 'b_port': '5', 'b_side': 'front', 'status': 'installed',
'cable_type': '', 'length_m': None, 'color': '', 'notes': '', 'label_applied': False}],
'port_labels': [{'item_id': 2, 'item_name': 'PP1', 'port': '5', 'label': 'OFFICE', 'applied': False}],
}
data = client.get('/api/rack', headers=AUTH).get_json()
assert data['units'] == 42 and data['unplaced'] == ['Loose']
assert [i['name'] for i in data['items']] == ['PP1', 'USW Flex']
assert data['overlaps'] == [{'name': 'Shelf', 'units': 'U20', 'with': ['USW Flex']}]
pp, sw = data['items']
assert pp['labels'] == {'5': 'OFFICE'} and pp['url'] == '/cutsheet#item-2'
assert pp['ports']['5']['run'] == [7] and pp['ports']['5']['cable_id'] == 7
assert sw['url'] == '/device/USW%20Flex' and sw['switch']['model'] == 'USF5P' # model from UniFi
assert sw['ports']['2']['mark'] in ('ok', 'bad', 'doc')
def test_rack_page_and_auth(self, client):
assert 'rack.js' in client.get('/rack', headers=AUTH).get_data(as_text=True)
assert client.get('/api/rack').status_code == 401
def test_units_from_config(self, client):
gandalf._cutsheet_schema_ready = True
gandalf.db.cutsheet_load.return_value = {'items': [], 'cables': [], 'port_labels': []}
with patch.object(gandalf, '_cfg', dict(CONFIG, rack={'units': 24})):
assert client.get('/api/rack', headers=AUTH).get_json()['units'] == 24
class TestRackRacksShelvesLinks:
def _items(self, *items):
base = {'port_count': None, 'rack_u': None, 'rack_height': None, 'rack': '', 'shelf': '', 'device': '',
'location': '', 'notes': ''}
gandalf._cutsheet_schema_ready = True
gandalf.db.cutsheet_load.return_value = {
'items': [dict(base, id=n, **i) for n, i in enumerate(items, 1)], 'cables': [], 'port_labels': []}
def test_product_named_item_links_to_its_device(self, client):
self._items({'name': 'Flex (desk)', 'kind': 'device', 'rack_u': 5, 'rack_height': 1, 'device': 'USW Flex'})
item = client.get('/api/rack', headers=AUTH).get_json()['items'][0]
assert item['device'] == 'USW Flex' and item['linked'] and item['url'] == '/device/USW%20Flex'
assert item['status'] == 'up' and item['switch']['model'] == 'USF5P'
def test_unlinked_item(self, client):
self._items({'name': 'UNVR-Pro', 'kind': 'device', 'rack_u': 5, 'rack_height': 2})
item = client.get('/api/rack', headers=AUTH).get_json()['items'][0]
assert not item['linked'] and item['url'] == '/cutsheet#item-1' and 'switch' not in item
def test_drawn_front_is_passed_through(self, client):
self._items({'name': 'UNVR-Pro', 'kind': 'device', 'rack_u': 5, 'rack_height': 2, 'chassis': 'unvr-pro'})
assert client.get('/api/rack', headers=AUTH).get_json()['items'][0]['chassis'] == 'unvr-pro'
def test_shelf_lists_what_is_on_it(self, client):
self._items({'name': 'Shelf', 'kind': 'shelf', 'rack_u': 3, 'rack_height': 1},
{'name': 'large1', 'kind': 'device', 'shelf': 'Shelf'},
{'name': 'Mini', 'kind': 'device', 'shelf': 'Shelf', 'device': 'USW Flex'})
data = client.get('/api/rack', headers=AUTH).get_json()
assert [i['name'] for i in data['items']] == ['Shelf'] and data['unplaced'] == []
assert [(c['name'], c['status']) for c in data['items'][0]['contents']] == [('large1', 'up'), ('Mini', 'up')]
def test_racks_tabs_and_selection(self, client):
self._items({'name': 'A', 'kind': 'other', 'rack_u': 1, 'rack_height': 1},
{'name': 'B', 'kind': 'other', 'rack_u': 1, 'rack_height': 1, 'rack': 'Garage'})
cfg = dict(CONFIG, racks=[{'name': 'Main', 'units': 24}])
with patch.object(gandalf, '_cfg', cfg):
data = client.get('/api/rack', headers=AUTH).get_json()
assert [(r['id'], r['name'], r['units'], r['count']) for r in data['racks']] == [
(None, 'Main', 24, 1), (None, 'Garage', 42, 1)]
assert data['rack'] == 'Main' and [i['name'] for i in data['items']] == ['A']
garage = client.get('/api/rack?rack=Garage', headers=AUTH).get_json()
assert [i['name'] for i in garage['items']] == ['B'] and garage['units'] == 42
assert client.get('/api/rack?rack=Nope', headers=AUTH).status_code == 404
class TestRackFacesAndSettings:
def _items(self, *items):
base = {'port_count': None, 'rack_u': None, 'rack_height': None, 'rack': '', 'shelf': '', 'device': '',
'mount': 'front', 'location': '', 'notes': ''}
gandalf._cutsheet_schema_ready = True
gandalf.db.cutsheet_load.return_value = {
'items': [dict(base, id=n, **i) for n, i in enumerate(items, 1)], 'cables': [], 'port_labels': []}
def test_rear_face(self, client):
self._items({'name': 'Server', 'kind': 'device', 'rack_u': 5, 'rack_height': 4, 'mount': 'full'},
{'name': 'PDU', 'kind': 'device', 'rack_u': 12, 'rack_height': 1, 'mount': 'rear'},
{'name': 'Switch', 'kind': 'device', 'rack_u': 12, 'rack_height': 1})
front = client.get('/api/rack', headers=AUTH).get_json()
rear = client.get('/api/rack?face=rear', headers=AUTH).get_json()
assert [(i['name'], i['through']) for i in front['items']] == [('Switch', False), ('Server', False)]
assert [(i['name'], i['through']) for i in rear['items']] == [('PDU', False), ('Server', True)]
assert rear['face'] == 'rear' and rear['racks'][0]['rear'] == 2 and rear['racks'][0]['count'] == 3
assert client.get('/api/rack?face=side', headers=AUTH).status_code == 400
def test_saved_racks_replace_config(self, client):
self._items()
gandalf.db.cutsheet_racks.return_value = [{'id': 4, 'name': 'StarTech 25U', 'units': 25, 'notes': 'open frame'}]
data = client.get('/api/rack', headers=AUTH).get_json()
assert (data['rack'], data['rack_id'], data['units'], data['notes']) == ('StarTech 25U', 4, 25, 'open frame')
def test_first_save_carries_the_default_racks_items(self, client):
gandalf._cutsheet_schema_ready = True
gandalf.db.cutsheet_save_rack.return_value = 7
resp = client.post('/api/cutsheet/racks', json={'name': 'StarTech 25U', 'units': 25, 'previous': 'Rack 1'},
headers=AUTH)
assert resp.get_json() == {'success': True, 'id': 7}
args, kwargs = gandalf.db.cutsheet_save_rack.call_args
assert args[0] is None and args[1]['units'] == 25 and kwargs == {'previous': 'Rack 1'}
def test_later_racks_ignore_previous(self, client):
gandalf._cutsheet_schema_ready = True
gandalf.db.cutsheet_racks.return_value = [{'id': 4, 'name': 'A', 'units': 25, 'notes': ''}]
client.post('/api/cutsheet/racks', json={'name': 'B', 'units': 42, 'previous': 'A'}, headers=AUTH)
assert gandalf.db.cutsheet_save_rack.call_args.kwargs == {'previous': ''}
def test_rack_writes_need_admin_and_valid_data(self, client):
gandalf._cutsheet_schema_ready = True
assert client.post('/api/cutsheet/racks', json={'name': 'x', 'units': 99}, headers=AUTH).status_code == 400
user = dict(AUTH, **{'Remote-Groups': 'staff'})
with patch.object(gandalf, '_cfg', dict(CONFIG, auth=dict(CONFIG['auth'], allowed_groups=['admin', 'staff']))):
assert client.put('/api/cutsheet/racks/1', json={'name': 'x', 'units': 2}, headers=user).status_code == 403
gandalf.db.cutsheet_delete_rack.return_value = False
assert client.delete('/api/cutsheet/racks/9', headers=AUTH).status_code == 404
+371
View File
@@ -0,0 +1,371 @@
"""Tests for cutsheet.py: validation, path tracing and plan-vs-actual checks."""
import os
import sys
import pytest
sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
import cutsheet as cs # noqa: E402
PANEL = {'id': 1, 'name': 'PP1', 'kind': 'patch_panel', 'port_count': 24}
JACK = {'id': 2, 'name': 'Bedroom jack', 'kind': 'wall_jack', 'port_count': 2}
SHELF = {'id': 3, 'name': 'Shelf', 'kind': 'shelf', 'port_count': None}
ITEMS = {i['name']: i for i in (PANEL, JACK, SHELF)}
def cable(cid, a, b=None, status='installed', label=None, **kw):
a_dev, a_port, a_side = (a + ('',) * 3)[:3]
b_dev, b_port, b_side = ((b or ('', '', '')) + ('',) * 3)[:3]
c = {'id': cid, 'label': label, 'a_device': a_dev, 'a_port': a_port, 'a_side': a_side,
'b_device': b_dev, 'b_port': b_port, 'b_side': b_side, 'status': status,
'cable_type': '', 'length_m': None, 'color': '', 'notes': '', 'label_applied': False}
c.update(kw)
return c
def switch(ports):
return {'sw': {'ports': {f'Port {p["port_idx"]}': p for p in ports}}}
def port(idx, up=True, seen='', **kw):
p = {'port_idx': idx, 'up': up}
if seen:
p['lldp'] = {'system_name': seen}
p.update(kw)
return p
class TestValidation:
def test_minimal_cable(self):
c = cs.validate_cable({'a_device': 'sw', 'a_port': '3'}, ITEMS)
assert c['status'] == 'installed' and c['label'] is None and c['b_device'] == ''
def test_panel_needs_side_and_valid_port(self):
with pytest.raises(cs.ValidationError, match='front or rear'):
cs.validate_cable({'a_device': 'PP1', 'a_port': '3'}, ITEMS)
with pytest.raises(cs.ValidationError, match='ports 1 to 24'):
cs.validate_cable({'a_device': 'PP1', 'a_port': '25', 'a_side': 'front'}, ITEMS)
c = cs.validate_cable({'a_device': 'PP1', 'a_port': '3', 'a_side': 'rear'}, ITEMS)
assert c['a_side'] == 'rear'
def test_side_is_dropped_for_active_devices(self):
c = cs.validate_cable({'a_device': 'sw', 'a_port': '3', 'a_side': 'front'}, ITEMS)
assert c['a_side'] == ''
@pytest.mark.parametrize('data, message', [
({}, 'From device is required'),
({'a_device': 'sw', 'label': 'bad label!'}, 'Label may use'),
({'a_device': 'sw', 'status': 'gone'}, 'status must be'),
({'a_device': 'sw', 'cable_type': 'Cat9'}, 'Type must be'),
({'a_device': 'sw', 'length_m': 'long'}, 'Length must be a number'),
({'a_device': 'sw', 'length_m': '0'}, 'between 0 and 999'),
({'a_device': 'sw', 'b_port': '3'}, 'Choose a device before a port'),
({'a_device': 'sw', 'a_port': '1', 'b_device': 'sw', 'b_port': '1'}, 'same port'),
({'a_device': 'x' * 101}, '100 characters'),
])
def test_rejects(self, data, message):
with pytest.raises(cs.ValidationError, match=message):
cs.validate_cable(data, ITEMS)
def test_item_rules(self):
assert cs.validate_item({'name': 'S', 'kind': 'shelf', 'rack_u': '5'})['rack_height'] == 1
with pytest.raises(cs.ValidationError, match='port count'):
cs.validate_item({'name': 'P', 'kind': 'patch_panel'})
with pytest.raises(cs.ValidationError, match='rack unit to go with'):
cs.validate_item({'name': 'S', 'rack_height': '2'})
with pytest.raises(cs.ValidationError, match='kind must be'):
cs.validate_item({'name': 'S', 'kind': 'rack'})
def test_next_label_fills_gaps(self):
assert cs.next_label([]) == 'C01'
assert cs.next_label([{'label': 'C01'}, {'label': 'c03'}, {'label': 'X9'}]) == 'C02'
class TestTrace:
def test_switch_through_panel_to_jack(self):
cables = [
cable(1, ('sw', '13'), ('PP1', '5', 'front')),
cable(2, ('PP1', '5', 'rear'), ('Bedroom jack', '1', 'rear')),
cable(3, ('Bedroom jack', '1', 'front'), ('tv', 'eth0')),
]
for start in cables:
hops = cs.trace(start, cables, ITEMS)['hops']
ends = {hops[0][0], hops[-1][0]}
assert ends == {'sw', 'tv'}
assert cs.trace(start, cables, ITEMS)['cable_ids'] in ([1, 2, 3], [3, 2, 1])
def test_retired_cables_are_not_followed(self):
cables = [cable(1, ('sw', '1'), ('PP1', '1', 'front')),
cable(2, ('PP1', '1', 'rear'), ('Bedroom jack', '1', 'rear'), status='retired')]
assert cs.trace(cables[0], cables, ITEMS)['cable_ids'] == [1]
def test_unterminated_end(self):
hops = cs.trace(cable(1, ('PP1', '9', 'rear')), [cable(1, ('PP1', '9', 'rear'))], ITEMS)['hops']
assert hops[-1] is None
class TestEvaluate:
def verdict(self, cables, switches, cid=1):
return cs.evaluate(cables, ITEMS, switches)[cid]['verdict']
def test_match_through_a_panel(self):
cables = [cable(1, ('sw', '13'), ('PP1', '5', 'front')),
cable(2, ('PP1', '5', 'rear'), ('tv', 'eth0'))]
assert self.verdict(cables, switch([port(13, seen='tv')])) == 'match'
assert self.verdict(cables, switch([port(13, seen='TV ')]), cid=2) == 'match'
def test_wrong_neighbor(self):
cables = [cable(1, ('sw', '13'), ('tv', 'eth0'))]
result = cs.evaluate(cables, ITEMS, switch([port(13, seen='printer')]))[1]
assert result['verdict'] == 'wrong_neighbor' and 'printer' in result['detail']
def test_no_link_vs_idle(self):
assert self.verdict([cable(1, ('sw', '13'), ('tv', 'eth0'))], switch([port(13, up=False)])) == 'no_link'
# A run that ends at a jack with nothing plugged in is normal
jack = [cable(1, ('sw', '13'), ('Bedroom jack', '1', 'rear'))]
assert self.verdict(jack, switch([port(13, up=False)])) == 'idle'
def test_unverified_when_nothing_identifies_the_far_end(self):
assert self.verdict([cable(1, ('sw', '13'), ('tv', 'eth0'))], switch([port(13)])) == 'unverified'
jack = [cable(1, ('sw', '13'), ('Bedroom jack', '1', 'rear'))]
result = cs.evaluate(jack, ITEMS, switch([port(13, seen='camera')]))[1]
assert result['verdict'] == 'unverified' and 'camera' in result['detail']
def test_missing_port_and_unknown_devices(self):
assert self.verdict([cable(1, ('sw', '99'), ('tv', 'eth0'))], switch([port(13)])) == 'missing_port'
assert self.verdict([cable(1, ('host-a', 'eth0'), ('host-b', 'eth0'))], switch([])) == 'not_checked'
def test_statuses_skip_the_check(self):
for status in ('planned', 'dark', 'retired'):
cables = [cable(1, ('sw', '13'), ('tv', 'eth0'), status=status)]
assert self.verdict(cables, switch([port(13, seen='printer')])) == status
def test_a_planned_hop_makes_the_run_planned(self):
cables = [cable(1, ('sw', '13'), ('PP1', '5', 'front')),
cable(2, ('PP1', '5', 'rear'), ('tv', 'eth0'), status='planned')]
assert self.verdict(cables, switch([port(13, seen='printer')])) == 'planned'
def test_dac_serial_confirms_both_ends(self):
switches = {
'gw': {'ports': {'p': port(11, sfp={'kind': 'dac', 'cable_peer': {'switch': 'agg', 'port_idx': 7}})}},
'agg': {'ports': {'p': port(7, sfp={'kind': 'dac', 'cable_peer': {'switch': 'gw', 'port_idx': 11}})}},
}
result = cs.evaluate([cable(1, ('gw', '11'), ('agg', '7'))], ITEMS, switches)[1]
assert result['verdict'] == 'match' and 'DAC' in result['detail']
def test_switch_to_switch_reports_the_worse_end(self):
switches = {'a': {'ports': {'p': port(1, seen='b')}}, 'b': {'ports': {'p': port(2, seen='c')}}}
assert self.verdict([cable(1, ('a', '1'), ('b', '2'))], switches) == 'wrong_neighbor'
def test_two_installed_cables_on_one_port_conflict(self):
cables = [cable(1, ('sw', '13'), ('tv', 'eth0'), label='C01'),
cable(2, ('sw', '13'), ('printer', 'eth0'), label='C02'),
cable(3, ('sw', '13'), ('tv', 'eth0'), status='planned')]
result = cs.evaluate(cables, ITEMS, switch([port(13, seen='tv')]))
assert result[1]['verdict'] == 'conflict' and 'C02' in result[1]['detail']
assert result[3]['verdict'] == 'planned'
class TestUndocumented:
def test_lists_live_ports_without_a_cable(self):
switches = switch([port(1, seen='tv'), port(2), port(3, up=False)])
found = cs.undocumented([cable(1, ('sw', '2'), ('x', ''))], switches)
assert [(s['port_idx'], s['neighbor']) for s in found] == [(1, 'tv')]
def test_retired_cables_dont_count(self):
found = cs.undocumented([cable(1, ('sw', '1'), ('x', ''), status='retired')], switch([port(1)]))
assert len(found) == 1
def test_dac_offered_once_from_one_end(self):
switches = {
'agg': {'ports': {'p': port(7, sfp={'kind': 'dac', 'cable_peer': {'switch': 'gw', 'port_idx': 11}})}},
'gw': {'ports': {'p': port(11, sfp={'kind': 'dac', 'cable_peer': {'switch': 'agg', 'port_idx': 7}})}},
}
found = cs.undocumented([], switches)
assert len(found) == 1 and found[0]['cable_type'] == 'DAC' and found[0]['via'] == 'DAC serial'
class TestLabels:
def test_only_unapplied_labels_of_live_cables(self):
cables = [cable(1, ('sw', '1'), ('tv', ''), label='C10'), cable(2, ('sw', '2'), ('tv', ''), label='C2'),
cable(3, ('sw', '3'), ('tv', ''), label='C3', label_applied=True),
cable(4, ('sw', '4'), label='C4', status='dark'),
cable(5, ('sw', '5'), ('tv', ''), label='C5', status='planned'),
cable(6, ('sw', '6'), ('tv', ''))]
ports = [{'item_name': 'PP1', 'port': '10', 'label': 'OFFICE', 'applied': False},
{'item_name': 'PP1', 'port': '2', 'label': 'GARAGE', 'applied': False},
{'item_name': 'PP1', 'port': '3', 'label': 'DONE', 'applied': True}]
out = cs.labels_to_make(cables, ITEMS, ports)
assert [c['text'] for c in out['cables']] == ['C2', 'C4', 'C10']
assert [c['copies'] for c in out['cables']] == [2, 1, 2]
assert [p['text'] for p in out['ports']] == ['GARAGE', 'OFFICE']
assert out['unlabeled_cable_ids'] == [6]
class TestCsv:
def test_round_trip(self):
original = [cable(1, ('sw', '13'), ('PP1', '5', 'front'), label='C01', cable_type='Cat6',
length_m=1.5, color='white', label_applied=True, notes='to office, via panel')]
rows, errors = cs.parse_csv(cs.cables_to_csv(original), ITEMS)
assert errors == []
assert rows[0]['label'] == 'C01' and rows[0]['b_side'] == 'front' and rows[0]['length_m'] == 1.5
assert rows[0]['label_applied'] is True and rows[0]['notes'] == 'to office, via panel'
def test_formulas_are_neutralised_and_restored(self):
text = cs.cables_to_csv([cable(1, ('sw', '1'), label='C01', notes='=HYPERLINK("x")')])
assert "'=HYPERLINK" in text
rows, _ = cs.parse_csv(text, ITEMS)
assert rows[0]['notes'] == '=HYPERLINK("x")'
def test_any_bad_row_is_reported(self):
text = 'label,a_device,a_port,a_side\nC01,sw,1,\nC01,sw,2,\n,PP1,40,front\n'
rows, errors = cs.parse_csv(text, ITEMS)
assert any('appears twice' in e for e in errors) and any('Line 4' in e for e in errors)
def test_missing_required_column(self):
assert cs.parse_csv('label\nC1\n', ITEMS) == ([], ['Missing column: a_device'])
class TestProblems:
def test_one_problem_per_run_named_after_the_switch_cable(self):
cables = [cable(1, ('PP1', '5', 'rear'), ('tv', 'eth0')),
cable(2, ('sw', '13'), ('PP1', '5', 'front'), label='C07')]
found = cs.problems(cables, ITEMS, switch([port(13, seen='printer')]))
assert len(found) == 1
p = found[0]
assert (p['label'], p['switch'], p['port'], p['verdict']) == ('C07', 'sw', '13', 'wrong_neighbor')
assert p['key'] == 'cable 2' and 'PP1 port 5 (front)' in p['path']
def test_only_installed_problems(self):
cables = [cable(1, ('sw', '13'), ('tv', 'eth0'), status='planned'),
cable(2, ('sw', '14'), ('tv', 'eth0')),
cable(3, ('sw', '15'), ('Bedroom jack', '1', 'rear'))]
switches = switch([port(13, seen='x'), port(14, seen='tv'), port(15, up=False)])
assert cs.problems(cables, ITEMS, switches) == []
def test_each_conflicting_cable_is_reported(self):
cables = [cable(1, ('sw', '13'), ('tv', 'eth0')), cable(2, ('sw', '13'), ('pc', 'eth0'))]
found = cs.problems(cables, ITEMS, switch([port(13, seen='tv')]))
assert sorted(p['cable_id'] for p in found) == [1, 2]
class TestRackLayout:
_ids = {}
def _item(self, name, u, h=None):
# IDs in creation order: on a tie for the same top unit, the earlier record is drawn
return {'id': self._ids.setdefault(name, len(self._ids) + 1), 'name': name, 'kind': 'device',
'rack_u': u, 'rack_height': h}
def test_top_first_with_top_unit(self):
out = cs.rack_layout([self._item('a', 1), self._item('b', 10, 2), {'name': 'loose', 'rack_u': None}], 42)
assert [(i['name'], i['rack_top']) for i in out['placed']] == [('b', 11), ('a', 1)]
assert out['overlaps'] == [] and out['outside'] == []
def test_overlap_is_reported_not_drawn(self):
out = cs.rack_layout([self._item('ups', 1, 2), self._item('shelf', 2)], 42)
assert [i['name'] for i in out['placed']] == ['ups']
assert out['overlaps'] == [{'name': 'shelf', 'units': 'U2', 'with': ['ups']}]
def test_past_the_top(self):
out = cs.rack_layout([self._item('tall', 41, 3)], 42)
assert out['placed'] == [] and out['outside'] == [{'name': 'tall', 'units': 'U41-43'}]
class TestPortMarks:
def test_worst_cable_wins_and_runs_merge(self):
cables = [
dict(cable(1, ('sw', '3'), ('PP1', '1', 'front'), label='C1'), verdict='match', detail='ok', run=[1, 2]),
dict(cable(2, ('PP1', '1', 'rear'), ('jack', '1')), verdict='wrong_neighbor', detail='bad', run=[1, 2]),
dict(cable(3, ('sw', '4'), ('x',)), verdict='planned', detail='Planned', run=[3]),
dict(cable(4, ('sw', '5'), ('y',), status='retired'), verdict='retired', detail='', run=[4]),
]
marks = cs.port_marks(cables)
assert marks[('sw', '3')]['mark'] == 'ok'
assert marks[('PP1', '1')]['mark'] == 'bad' and marks[('PP1', '1')]['cable_id'] == 2
assert marks[('PP1', '1')]['run'] == [1, 2]
assert marks[('PP1', '1')]['text'] == 'cable C1: ok; cable #2: bad'
assert marks[('sw', '4')]['text'] == 'cable #3: Planned'
assert marks[('sw', '4')]['mark'] == 'doc'
assert ('sw', '5') not in marks and ('x', '') not in marks
def test_shared_check_is_said_once(self):
cables = [
dict(cable(1, ('sw', '3'), ('PP1', '1', 'front'), label='C1'), verdict='idle', detail='Idle', run=[1, 2]),
dict(cable(2, ('PP1', '1', 'rear'), ('jack', '1')), verdict='idle', detail='Idle', run=[1, 2]),
]
assert cs.port_marks(cables)[('PP1', '1')]['text'] == 'cables C1, #2: Idle'
class TestDeviceAliases:
ITEMS = {'UDM-Pro': {'name': 'UDM-Pro', 'kind': 'device', 'device': 'udm'},
'Big box': {'name': 'Big box', 'kind': 'device', 'device': 'large1'}}
def test_cable_on_an_item_is_checked_against_its_device(self):
switches = {'udm': switch([port(3, seen='large1')])['sw']}
c = cable(1, ('UDM-Pro', '3'), ('Big box', 'eth0'))
assert cs.evaluate([c], self.ITEMS, switches)[1]['verdict'] == 'match'
def test_wrong_neighbor_still_caught_through_an_alias(self):
switches = {'udm': switch([port(3, seen='printer')])['sw']}
c = cable(1, ('UDM-Pro', '3'), ('Big box', 'eth0'))
assert cs.evaluate([c], self.ITEMS, switches)[1]['verdict'] == 'wrong_neighbor'
def test_aliased_cable_counts_as_documented(self):
switches = {'udm': switch([port(3, seen='large1')])['sw']}
c = cable(1, ('UDM-Pro', '3'), ('Big box', 'eth0'))
assert cs.undocumented([c], switches, self.ITEMS) == []
assert len(cs.undocumented([c], switches)) == 1
def test_runs_for_the_device_include_aliased_cables(self):
c = cable(1, ('UDM-Pro', '3'), ('Big box', 'eth0'), label='C1')
assert [r['label'] for r in cs.runs_for('udm', [c], self.ITEMS, {})] == ['C1']
class TestRackFaces:
def _item(self, name, u, h=1, mount='front', id_=1):
return {'id': id_, 'name': name, 'kind': 'device', 'rack_u': u, 'rack_height': h, 'mount': mount}
def test_front_and_rear_share_a_unit(self):
items = [self._item('switch', 10), self._item('pdu', 10, mount='rear', id_=2)]
front = cs.rack_layout(items, 25, 'front')
rear = cs.rack_layout(items, 25, 'rear')
assert [i['name'] for i in front['placed']] == ['switch'] and front['overlaps'] == []
assert [i['name'] for i in rear['placed']] == ['pdu'] and rear['overlaps'] == []
def test_full_depth_takes_both_sides(self):
items = [self._item('server', 5, 4, mount='full'), self._item('pdu', 6, mount='rear', id_=2)]
rear = cs.rack_layout(items, 25, 'rear')
assert [(i['name'], i['through']) for i in rear['placed']] == [('server', True)]
assert rear['overlaps'] == [{'name': 'pdu', 'units': 'U6', 'with': ['server']}]
front = cs.rack_layout(items, 25, 'front')
assert [(i['name'], i['through']) for i in front['placed']] == [('server', False)]
assert front['overlaps'] == rear['overlaps'] # reported on both faces
def test_mount_is_validated_and_shelf_items_take_the_shelf_side(self):
assert cs.validate_item({'name': 'p', 'mount': 'rear', 'rack_u': 3})['mount'] == 'rear'
assert cs.validate_item({'name': 'p'})['mount'] == 'front'
with pytest.raises(cs.ValidationError):
cs.validate_item({'name': 'p', 'mount': 'side'})
shelf = {'Shelf': {'name': 'Shelf', 'kind': 'shelf'}}
assert cs.validate_item({'name': 'm', 'shelf': 'Shelf', 'mount': 'rear'}, shelf)['mount'] == 'front'
def test_validate_rack(self):
rack = cs.validate_rack({'name': ' StarTech 25U ', 'units': '25'})
assert rack == {'name': 'StarTech 25U', 'units': 25, 'notes': ''}
for bad in ({'name': '', 'units': 25}, {'name': 'x'}, {'name': 'x', 'units': 61}, {'name': 'x', 'units': 0}):
with pytest.raises(cs.ValidationError):
cs.validate_rack(bad)
class TestChassis:
def test_known_drawing_kept_unknown_refused(self):
assert cs.validate_item({'name': 'nvr', 'chassis': 'unvr-pro'})['chassis'] == 'unvr-pro'
assert cs.validate_item({'name': 'x'})['chassis'] == ''
with pytest.raises(cs.ValidationError):
cs.validate_item({'name': 'x', 'chassis': 'tardis'})
def test_every_drawing_has_a_label(self):
assert all(cs.CHASSIS.values())
assert {'sliger-cx4712', 'rosewill-rsv-l4500u', 'unvr-pro', 'uacc-patch-24'} <= set(cs.CHASSIS)
+1 -1
View File
@@ -1,4 +1,4 @@
"""Tests for gandalf.diagnose — all pure static methods, no external deps."""
"""Tests for gandalf.diagnose: all pure static methods, no external deps."""
import sys
import os
sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
+336 -2
View File
@@ -3,6 +3,7 @@ import json
import os
import sys
import time
from datetime import timedelta
from unittest.mock import MagicMock, patch
import pytest
@@ -24,6 +25,12 @@ def db():
mock_db.upsert_event.return_value = (1, False, 2, None)
mock_db.get_modem_rx_values.return_value = []
mock_db.get_state.return_value = None
mock_db.event_stats.return_value = {'last_7d': 0, 'last_30d': 0,
'last_first_seen': None, 'last_resolved_at': None}
mock_db.get_events_for_target.return_value = []
mock_db.cutsheet_load.return_value = {'items': [], 'cables': [], 'port_labels': []}
mock_db.get_pending_recovery_notes.return_value = []
mock_db.get_device_link.return_value = ''
yield mock_db
@@ -32,6 +39,7 @@ def mon(db):
m = monitor.NetworkMonitor.__new__(monitor.NetworkMonitor)
m.cfg = {}
m.fail_thresh = 2
m.host_fail_thresh = 5
m.cluster_thresh = 2
m.cluster_name = 'test-cluster'
m.tickets = MagicMock()
@@ -72,6 +80,7 @@ def healthy_modem(rx=-16.9, rx_status=None):
class TestDeadHostDetection:
def test_host_missing_from_prometheus_alerts_and_tickets(self, mon, db):
db.upsert_event.return_value = (1, False, 5, None)
mon._process_interfaces({HOST_A: {'eth0': True}}, [])
assert ('host_metrics_missing', 'beta', HOST_B) in upserted(db)
assert 'No metrics' in mon.tickets.create.call_args.args[0]
@@ -86,7 +95,19 @@ class TestDeadHostDetection:
mon._process_interfaces({HOST_A: {'eth0': True}}, [])
assert not mon.tickets.create.called
def test_reboot_length_outage_is_recorded_without_a_ticket(self, mon, db):
db.upsert_event.return_value = (1, False, 4, None)
mon._process_interfaces({HOST_A: {'eth0': True}}, [])
assert ('host_metrics_missing', 'beta', HOST_B) in upserted(db)
assert not mon.tickets.create.called
def test_interface_down_keeps_the_shorter_threshold(self, mon, db):
db.get_baseline.return_value = {'alpha': {'eth0': 'up'}, 'beta': {'eth0': 'up'}}
mon._process_interfaces({HOST_A: {'eth0': False}, HOST_B: {'eth0': True}}, [])
assert 'Interface eth0 link-down' in mon.tickets.create.call_args.args[0]
def test_suppressed_host_gets_no_ticket(self, mon, db):
db.upsert_event.return_value = (1, False, 5, None)
db.check_suppressed.return_value = True
mon._process_interfaces({HOST_A: {'eth0': True}}, [])
assert not mon.tickets.create.called
@@ -150,24 +171,42 @@ class TestPingUnknown:
mon._process_ping_hosts([], {'pbs': False})
assert ('host_unreachable', 'pbs', '10.0.0.3') in upserted(db)
def test_ping_host_ticket_waits_out_a_reboot(self, mon, db):
mon.cfg = {'monitor': {'ping_hosts': [{'name': 'pbs', 'ip': '10.0.0.3'}]}}
db.upsert_event.return_value = (1, False, 4, None)
mon._process_ping_hosts([], {'pbs': False})
assert not mon.tickets.create.called
db.upsert_event.return_value = (1, False, 5, None)
mon._process_ping_hosts([], {'pbs': False})
assert 'Host unreachable' in mon.tickets.create.call_args.args[0]
class TestUnifiRates:
def _collector(self):
c = monitor.LinkStatsCollector.__new__(monitor.LinkStatsCollector)
c._prev_unifi_time = 100.0
c._prev_unifi = {'sw': {'ports': {'Port 1': {
'tx_bytes': 100, 'rx_bytes': 100, 'tx_errors': 0, 'rx_errors': 0, 'tx_dropped': 0, 'rx_dropped': 0,
'port_idx': 1, 'tx_bytes': 100, 'rx_bytes': 100,
'tx_errors': 0, 'rx_errors': 0, 'tx_dropped': 0, 'rx_dropped': 0,
}}}}
return c
def test_new_port_has_no_rate_spike(self):
port = {'tx_bytes': 10**12, 'rx_bytes': 10**12, 'tx_errors': 5, 'rx_errors': 5,
'tx_dropped': 5, 'rx_dropped': 5}
raw = {'sw': {'ip': '', 'model': '', 'ports': {'Port 1': dict(port, tx_bytes=300), 'Port 2': port}}}
raw = {'sw': {'ip': '', 'model': '', 'ports': {
'Port 1': dict(port, port_idx=1, tx_bytes=300), 'Port 2': dict(port, port_idx=2)}}}
result = self._collector()._compute_unifi_rates(raw, 200.0)['sw']['ports']
assert result['Port 2']['tx_bytes_rate'] is None
assert result['Port 1']['tx_bytes_rate'] == 2.0
def test_port_renamed_in_unifi_keeps_its_rates(self):
port = {'port_idx': 1, 'tx_bytes': 300, 'rx_bytes': 100, 'tx_errors': 0, 'rx_errors': 0,
'tx_dropped': 0, 'rx_dropped': 0}
raw = {'sw': {'ip': '', 'model': '', 'ports': {'Office TV': port}}}
result = self._collector()._compute_unifi_rates(raw, 200.0)['sw']['ports']
assert result['Office TV']['tx_bytes_rate'] == 2.0
class TestModemAlerts:
def test_healthy_link_raises_nothing(self, mon, db):
@@ -375,6 +414,73 @@ class TestUnifiDeviceDetail:
assert c.get_system_events(0, modem_api.WAN_LOG_KEYS) is None
class TestSwitchPortCollection:
def test_ports_sharing_a_name_are_both_kept(self):
c = monitor.UnifiClient({'controller': 'https://u.test', 'api_key': 'k'})
resp = MagicMock()
resp.json.return_value = {'data': [{'type': 'usw', 'name': 'sw', 'port_table': [
{'port_idx': 13, 'name': 'Office TV', 'up': False},
{'port_idx': 14, 'name': 'Office TV', 'up': True},
{'port_idx': 15},
]}]}
c.session.get = MagicMock(return_value=resp)
ports = c.get_switch_ports()['sw']['ports']
assert {n: p['port_idx'] for n, p in ports.items()} == {
'Office TV': 13, 'Office TV (Port 14)': 14, 'Port 15': 15,
}
class TestSfpModules:
OPTIC = {'sfp_found': True, 'sfp_compliance': '10G BASE-SR', 'sfp_part': 'SFP-10G-SR', 'sfp_vendor': 'OEM',
'sfp_serial': 'YC1', 'sfp_rxpower': '-2.45', 'sfp_txpower': '-2.56', 'sfp_temperature': '40.6',
'sfp_voltage': '3.318', 'sfp_current': '7.564', 'sfp_rxfault': False, 'sfp_txfault': False}
def test_port_without_a_cage_has_no_module_info(self):
assert monitor.UnifiClient._sfp_detail({'port_idx': 1}) is None
def test_empty_cage(self):
assert monitor.UnifiClient._sfp_detail({'sfp_found': False}) == {'found': False}
def test_optic_with_readings(self):
d = monitor.UnifiClient._sfp_detail(self.OPTIC)
assert d['kind'] == 'optic' and d['rx_power_dbm'] == -2.45 and d['current_ma'] == 7.564
assert d['rx_fault'] is False
def test_dac_by_compliance_or_part_number(self):
assert monitor.UnifiClient._sfp_detail({'sfp_found': True, 'sfp_compliance': 'DAC'})['kind'] == 'dac'
d = monitor.UnifiClient._sfp_detail({'sfp_found': True, 'sfp_compliance': 'Unknown',
'sfp_part': 'SFP-H10GB-CU3M'})
assert d['kind'] == 'dac' and d['compliance'] == '' and d['rx_power_dbm'] is None
def test_unidentified_module_and_bad_readings(self):
d = monitor.UnifiClient._sfp_detail({'sfp_found': True, 'sfp_part': 'L56SF017-SD-R',
'sfp_rxpower': 'n/a'})
assert d['kind'] == '' and d['rx_power_dbm'] is None
def test_udm_fault_flag_spelling(self):
d = monitor.UnifiClient._sfp_detail({'sfp_found': True, 'sfp_rx_los': True, 'sfp_tx_fault': True})
assert d['rx_fault'] is True and d['tx_fault'] is True
def test_dac_ends_are_paired_by_serial(self):
c = monitor.UnifiClient({'controller': 'https://u.test', 'api_key': 'k'})
dac = {'sfp_found': True, 'sfp_part': 'SFP-H10GB-CU1M', 'sfp_serial': 'CSC1'}
resp = MagicMock()
resp.json.return_value = {'data': [
{'type': 'udm', 'name': 'gw', 'port_table': [dict(dac, port_idx=11)]},
{'type': 'usw', 'name': 'agg', 'port_table': [
dict(dac, port_idx=7),
dict(dac, port_idx=1, sfp_serial='LONE'),
dict(self.OPTIC, port_idx=8),
]},
]}
c.session.get = MagicMock(return_value=resp)
sw = c.get_switch_ports()
assert sw['gw']['ports']['Port 11']['sfp']['cable_peer'] == {'switch': 'agg', 'port_idx': 7}
assert sw['agg']['ports']['Port 7']['sfp']['cable_peer'] == {'switch': 'gw', 'port_idx': 11}
assert 'cable_peer' not in sw['agg']['ports']['Port 1']['sfp']
assert 'cable_peer' not in sw['agg']['ports']['Port 8']['sfp']
class TestLldpCollection:
def _client_with(self, entry):
c = monitor.UnifiClient({'controller': 'https://u.test', 'api_key': 'k'})
@@ -414,3 +520,231 @@ class TestLldpCollection:
c = monitor.UnifiClient({'controller': 'https://u.test', 'api_key': 'k'})
c.session.get = MagicMock(side_effect=OSError('boom'))
assert c.get_wired_clients() == []
class TestCutsheetMismatch:
CABLE = {'id': 7, 'label': 'C07', 'a_device': 'sw', 'a_port': '13', 'a_side': '', 'b_device': 'tv',
'b_port': '', 'b_side': '', 'status': 'installed'}
def _run(self, mon, db, seen='printer', consec=1, ticket=None, suppressions=(), open_targets=()):
mon.poll_interval = 120
mon.cutsheet_ticket_hours = getattr(mon, 'cutsheet_ticket_hours', 24)
db.cutsheet_load.return_value = {'items': [], 'cables': [dict(self.CABLE)], 'port_labels': []}
db.upsert_event.return_value = (5, consec == 1, consec, ticket)
db.get_open_event_targets.return_value = list(open_targets)
db.check_suppressed.side_effect = lambda sups, kind, name, detail='': (kind, name) in sups
link = {'unifi_switches': {'sw': {'ports': {'Port 13': {
'port_idx': 13, 'up': True, 'lldp': {'system_name': seen}}}}}}
mon._process_cutsheet(link, list(suppressions))
def test_mismatch_opens_an_event_but_no_ticket_yet(self, mon, db):
self._run(mon, db)
args = db.upsert_event.call_args.args
assert args[:5] == ('cable_mismatch', 'warning', 'cutsheet', 'sw', 'cable 7')
assert 'printer' in args[5]
assert not mon.tickets.create.called
def test_ticket_after_a_day_of_polls(self, mon, db):
self._run(mon, db, consec=719)
assert not mon.tickets.create.called
self._run(mon, db, consec=720)
title = mon.tickets.create.call_args.args[0]
assert 'Cable C07 does not match the cutsheet' in title
assert mon.tickets.create.call_args.kwargs['priority'] == '4'
def test_no_second_ticket_and_suppression_respected(self, mon, db):
self._run(mon, db, consec=900, ticket='123')
self._run(mon, db, consec=900, suppressions=[('unifi_device', 'sw')])
assert not mon.tickets.create.called
def test_zero_hours_never_tickets(self, mon, db):
mon.cutsheet_ticket_hours = 0
self._run(mon, db, consec=10_000)
assert db.upsert_event.called and not mon.tickets.create.called
def test_fixed_cable_resolves_its_event(self, mon, db):
self._run(mon, db, seen='tv', open_targets=[('sw', 'cable 7'), ('other', 'cable 9')])
assert not db.upsert_event.called
resolved = {c.args for c in db.resolve_event.call_args_list}
assert ('cable_mismatch', 'sw', 'cable 7') in resolved and ('cable_mismatch', 'other', 'cable 9') in resolved
class TestTicketContext:
SWITCHES = {'agg': {'ports': {
'Large1': {'port_idx': 7, 'up': True, 'speed_mbps': 10000,
'lldp': {'system_name': 'large1', 'port_id': 'enp1s0f0'},
'sfp': {'found': True, 'kind': 'dac', 'part': 'DAC-10G'}},
'Port 3': {'port_idx': 3, 'up': False, 'speed_mbps': 0},
}}}
def _mon(self, mon, switches=None):
mon.public_url = 'https://gandalf.test'
mon.poll_interval = 120
mon._link_data = {'unifi_switches': switches if switches is not None else self.SWITCHES}
return mon
def _desc(self, mon):
return mon.tickets.create.call_args.args[1]
def test_interface_ticket_names_the_switch_port_and_links(self, mon, db):
self._mon(mon)._ticket_interface(1, 'large1', 'enp1s0f0', 2)
desc = self._desc(mon)
assert '### Where it is connected' in desc
assert '`enp1s0f0` → [agg port 7 "Large1": up at 10 Gbps, module: DAC DAC-10G]' in desc
assert '(https://gandalf.test/device/agg#port-7)' in desc
assert 'https://gandalf.test/device/large1' in desc
assert 'Opened automatically by Gandalf' in desc
assert 'inventory' not in desc
def test_inventory_link_when_set(self, mon, db):
db.get_device_link.return_value = 'https://inv.test/item/abc'
self._mon(mon)._ticket_interface(1, 'large1', 'enp1s0f0', 2)
assert '- [large1 in the inventory](https://inv.test/item/abc)' in self._desc(mon)
db.get_device_link.assert_called_with('large1')
def test_dead_host_uses_the_last_known_port(self, mon, db):
mon._known_uplinks = {'large1': {'seen': '2026-11-10 10:00:00 UTC', 'uplinks': [
{'switch': 'agg', 'port': 'Port 3', 'port_idx': 3, 'host_interface': 'eno1'}]}}
self._mon(mon)._ticket_metrics_missing(1, 'micro1', 'x:9100', 5)
assert 'not seen this device on a switch port' in self._desc(mon)
mon.tickets.create.reset_mock()
unplugged = {'agg': {'ports': {'Port 3': {'port_idx': 3, 'up': False}}}}
self._mon(mon, unplugged)._ticket_unreachable(1, 'large1', '10.0.0.9', 5)
desc = self._desc(mon)
assert 'agg port 3: down' in desc
assert 'last seen linked there 2026-11-10 10:00:00 UTC' in desc
assert 'Down for at least' in desc and '10 min' in desc
def test_cutsheet_runs_and_history(self, mon, db):
db.cutsheet_load.return_value = {'items': [], 'port_labels': [], 'cables': [
{'id': 4, 'label': 'C04', 'a_device': 'agg', 'a_port': '7', 'a_side': '',
'b_device': 'large1', 'b_port': 'enp1s0f0', 'b_side': '', 'status': 'installed'}]}
db.event_stats.return_value = {'last_7d': 3, 'last_30d': 5,
'last_first_seen': monitor._utcnow(), 'last_resolved_at': monitor._utcnow()}
self._mon(mon)._ticket_interface(1, 'large1', 'enp1s0f0', 2)
desc = self._desc(mon)
assert '[**C04**](https://gandalf.test/cutsheet#cable-4): agg port 7 → large1 enp1s0f0' in desc
assert 'Happened 3 times in the last 7 days and 5 in the last 30' in desc
assert 'This keeps coming back' in desc
def test_other_open_alerts_are_listed(self, mon, db):
db.get_events_for_target.return_value = [
{'id': 1, 'event_type': 'interface_down', 'target_name': 'large1', 'target_detail': 'eno1'},
{'id': 2, 'event_type': 'interface_down', 'target_name': 'large1', 'target_detail': 'eno2',
'first_seen': 'T', 'ticket_id': '55'},
{'id': 3, 'event_type': 'host_unreachable', 'target_name': 'large1', 'resolved_at': 'R'},
]
self._mon(mon)._ticket_interface(1, 'large1', 'eno1', 2)
desc = self._desc(mon)
assert '- interface down on large1 eno2 since T (ticket #55)' in desc
assert 'eno1 since' not in desc and 'host unreachable' not in desc
def test_a_failing_section_still_opens_the_ticket(self, mon, db):
db.event_stats.side_effect = RuntimeError('db gone')
self._mon(mon)._ticket_interface(1, 'large1', 'enp1s0f0', 2)
desc = self._desc(mon)
assert '### History' not in desc and '### Where it is connected' in desc
db.set_ticket_id.assert_called_with(1, '123')
def test_cable_mismatch_shows_the_switch_port(self, mon, db):
self._mon(mon)._ticket_cable_mismatch(9, {
'switch': 'agg', 'port': '7', 'cable_id': 4, 'label': 'C04', 'key': 'cable 4',
'detail': 'A different device is connected', 'path': 'agg port 7 → tv'}, 24)
desc = self._desc(mon)
assert '[C04](https://gandalf.test/cutsheet#cable-4)' in desc
assert '[agg port 7 "Large1": up at 10 Gbps' in desc
def test_titles_keep_the_tag_format(self, mon, db):
mon.unifi_fail_thresh = 3
self._mon(mon)._ticket_unifi(1, {'name': 'ap1', 'type': 'uap', 'model': 'U6', 'ip': '1.2.3.4'})
assert mon.tickets.create.call_args.args[0] == \
'[ap1][auto][production][issue][network][single-node] UniFi device offline'
def test_remember_uplinks_saves_only_on_change(self, mon, db):
self._mon(mon)
mon._known_uplinks = None
mon._remember_uplinks({'unifi_switches': self.SWITCHES})
saved = db.set_state.call_args.args
assert saved[0] == 'known_uplinks'
assert saved[1]['large1']['uplinks'] == [
{'switch': 'agg', 'port': 'Large1', 'port_idx': 7, 'host_interface': 'enp1s0f0'}]
db.set_state.reset_mock()
mon._remember_uplinks({'unifi_switches': self.SWITCHES})
assert not db.set_state.called
class TestRecoveryNotes:
def _event(self, **kw):
now = monitor._utcnow()
e = {'id': 8, 'event_type': 'host_metrics_missing', 'target_name': 'micro1', 'target_detail': 'x:9100',
'ticket_id': '993', 'first_seen': now - timedelta(minutes=12), 'resolved_at': now,
'consecutive_failures': 6}
e.update(kw)
return e
def test_cleared_alert_comments_and_marks(self, mon, db):
mon.public_url = 'https://gandalf.test'
mon.tickets.comments_denied = False
mon.tickets.comment.return_value = True
db.get_pending_recovery_notes.return_value = [self._event()]
mon._post_recovery_notes()
ticket_id, text = mon.tickets.comment.call_args.args
assert ticket_id == '993'
assert 'Cleared' in text and '12 min' in text and 'Failed checks:** 6' in text
assert 'https://gandalf.test/device/micro1' in text
db.mark_recovery_notified.assert_called_once_with(8)
assert db.get_pending_recovery_notes.call_args.kwargs['exclude_types'] == monitor.ONE_SHOT_EVENTS
def test_failed_comment_is_left_for_next_cycle(self, mon, db):
mon.tickets.comments_denied = False
mon.tickets.comment.return_value = False
db.get_pending_recovery_notes.return_value = [self._event(), self._event(id=9)]
mon._post_recovery_notes()
assert not db.mark_recovery_notified.called
assert mon.tickets.comment.call_count == 2
def test_denied_key_stops_trying(self, mon, db):
mon.tickets.comments_denied = True
mon._post_recovery_notes()
assert not db.get_pending_recovery_notes.called
def test_cable_mismatch_links_the_cutsheet(self, mon, db):
mon.public_url = 'https://gandalf.test'
url = mon._event_url({'event_type': 'cable_mismatch', 'target_name': 'sw', 'target_detail': 'cable 7'})
assert url == 'https://gandalf.test/cutsheet#cable-7'
class TestTicketClientComment:
def _client(self):
return monitor.TicketClient({'url': 'http://t.test/create_ticket_api.php', 'api_key': 'k'})
def test_comment_endpoint_sits_beside_create(self):
assert self._client().comment_url == 'http://t.test/api/ticket_comment_api.php'
sub = monitor.TicketClient({'url': 'http://t.test/tinker/create_ticket_api.php', 'api_key': 'k'})
assert sub.comment_url == 'http://t.test/tinker/api/ticket_comment_api.php'
def test_payload(self):
c = self._client()
resp = MagicMock(status_code=200)
resp.json.return_value = {'success': True, 'comment_id': 1}
with patch.object(monitor.requests, 'post', return_value=resp) as post:
assert c.comment('42', 'hi') is True
assert post.call_args.kwargs['json'] == {'ticket_id': '42', 'comment_text': 'hi', 'markdown_enabled': True}
assert post.call_args.kwargs['headers'] == {'Authorization': 'Bearer k'}
def test_forbidden_disables_comments(self):
c = self._client()
with patch.object(monitor.requests, 'post', return_value=MagicMock(status_code=403)) as post:
assert c.comment('42', 'hi') is False
assert c.comment('43', 'hi') is False
assert post.call_count == 1 and c.comments_denied
def test_missing_ticket_counts_as_done(self):
with patch.object(monitor.requests, 'post', return_value=MagicMock(status_code=404)):
assert self._client().comment('42', 'hi') is True
def test_network_error_is_retryable(self):
c = self._client()
with patch.object(monitor.requests, 'post', side_effect=OSError('down')):
assert c.comment('42', 'hi') is False
assert not c.comments_denied
+64
View File
@@ -0,0 +1,64 @@
"""Tests for ticket_text.py: the Markdown Gandalf puts in tickets."""
import os
import sys
from datetime import datetime, timedelta
sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
import ticket_text as tt # noqa: E402
NOW = datetime(2026, 11, 10, 18, 0)
def test_duration():
assert tt.duration(42) == '42 s'
assert tt.duration(600) == '10 min'
assert tt.duration(3600) == '1 h'
assert tt.duration(3 * 3600 + 120) == '3 h 2 min'
assert tt.duration(3 * 86400 + 7200) == '3 d 2 h'
def test_speed():
assert tt.speed(100) == '100 Mbps'
assert tt.speed(2500) == '2.5 Gbps'
assert tt.speed(10000) == '10 Gbps'
assert tt.speed(0) == ''
def test_device_url_escapes_names():
assert tt.device_url('https://g', 'USW Flex Mini', 3) == 'https://g/device/USW%20Flex%20Mini#port-3'
assert tt.device_url('', 'x') == ''
def test_port_text():
assert tt.port_text('sw', 'Port 4', {'port_idx': 4, 'up': True, 'speed_mbps': 1000, 'poe_power': 4.21}) == \
'sw port 4: up at 1 Gbps, PoE 4.2 W'
assert tt.port_text('sw', 'Cam', {'port_idx': 9, 'up': False,
'sfp': {'found': True, 'kind': 'optic', 'part': 'SR', 'rx_fault': True}}) == \
'sw port 9 "Cam": down, module: optic SR, **module reports a fault**'
def test_description_skips_empty_facts_and_sections():
text = tt.description('Alert', [('Host', 'a'), ('Blank', '')], 'Summary.', ['One', 'Two'],
[('Empty', []), ('Links', ['- x'])])
assert text.startswith('## Alert\n\n- **Host:** a\n\nSummary.')
assert 'Blank' not in text and '### Empty' not in text
assert '1. One\n2. Two' in text and '### Links\n- x' in text
def test_history_lines():
assert tt.history_lines({'last_7d': 0, 'last_30d': 0}, NOW) == ['- First time in the last 30 days.']
lines = tt.history_lines({'last_7d': 1, 'last_30d': 2, 'last_first_seen': NOW - timedelta(hours=26),
'last_resolved_at': NOW - timedelta(hours=25, minutes=55)}, NOW)
assert lines[0].startswith('- Happened 1 time in the last 7 days and 2')
assert lines[1] == '- Last cleared 2026-11-09 16:05 UTC (25 h 55 min ago), after 5 min.'
def test_recovery_comment():
text = tt.recovery_comment({'event_type': 'interface_down', 'target_name': 'large1', 'target_detail': 'eno1',
'first_seen': NOW - timedelta(minutes=7), 'resolved_at': NOW,
'consecutive_failures': 3}, NOW, 'https://g/device/large1')
assert text.startswith('**✅ Cleared**: interface down on large1 eno1.')
assert '- **Lasted:** 7 min (first seen 2026-11-10 17:53 UTC)' in text
assert '- **Gandalf:** https://g/device/large1' in text
assert 'leaves this ticket open' in text
+149
View File
@@ -0,0 +1,149 @@
"""Markdown for the tickets Gandalf opens in Tinker Tickets, and the notes it adds to them.
Pure formatting only: monitor.py gathers the facts and passes them in.
"""
from datetime import datetime, timezone
from typing import List, Optional, Sequence, Tuple
from urllib.parse import quote
Section = Tuple[str, List[str]]
def duration(seconds) -> str:
seconds = max(0, int(seconds))
if seconds < 60:
return f'{seconds} s'
minutes = seconds // 60
if minutes < 60:
return f'{minutes} min'
hours, minutes = divmod(minutes, 60)
if hours < 48:
return f'{hours} h {minutes} min' if minutes else f'{hours} h'
days, hours = divmod(hours, 24)
return f'{days} d {hours} h' if hours else f'{days} d'
def utc(dt: Optional[datetime]) -> str:
"""Database times are naive UTC."""
if dt is None:
return 'unknown'
if dt.tzinfo is not None:
dt = dt.astimezone(timezone.utc).replace(tzinfo=None)
return dt.strftime('%Y-%m-%d %H:%M UTC')
def speed(mbps) -> str:
if not mbps:
return ''
mbps = int(mbps)
if mbps >= 1000:
gbps = mbps / 1000
return f'{gbps:g} Gbps'
return f'{mbps} Mbps'
def device_url(base: str, name: str, port_idx=None) -> str:
if not base or not name:
return ''
url = f'{base}/device/{quote(name, safe="")}'
return f'{url}#port-{port_idx}' if port_idx not in (None, '') else url
def history_url(base: str, target: str) -> str:
return f'{base}/events?target={quote(target, safe="")}&range=90d' if base and target else ''
def cutsheet_url(base: str, cable_id) -> str:
return f'{base}/cutsheet#cable-{cable_id}' if base else ''
def link(text: str, url: str) -> str:
return f'[{text}]({url})' if url else text
def port_text(switch: str, port_name: str, port: dict) -> str:
"""'8SFP-AGG port 7 "Large1": up at 10 Gbps, DAC'"""
idx = port.get('port_idx')
text = f'{switch} port {idx}' if idx is not None else f'{switch} {port_name}'
if port_name and idx is not None and port_name != f'Port {idx}':
text += f' "{port_name}"'
state = []
if port.get('up'):
rate = speed(port.get('speed_mbps'))
state.append(f'up at {rate}' if rate else 'up')
else:
state.append('down')
if port.get('poe_power'):
state.append(f'PoE {float(port["poe_power"]):.1f} W')
sfp = port.get('sfp') or {}
if sfp.get('found'):
kind = 'DAC' if sfp.get('kind') == 'dac' else sfp.get('kind', '')
module = ' '.join(p for p in (kind, sfp.get('part', '')) if p)
if module:
state.append(f'module: {module}')
if sfp.get('rx_fault') or sfp.get('tx_fault'):
state.append('**module reports a fault**')
return f'{text}: {", ".join(state)}'
def description(heading: str, facts: Sequence[Tuple[str, str]], summary: str,
checks: Sequence[str], sections: Sequence[Section] = (), recovers: bool = True) -> str:
lines = [f'## {heading}', '']
lines += [f'- **{key}:** {value}' for key, value in facts if value not in (None, '')]
lines += ['', summary.strip()]
if checks:
lines += ['', '### What to check']
lines += [f'{n}. {check}' for n, check in enumerate(checks, 1)]
for title, body in sections:
if body:
lines += ['', f'### {title}'] + list(body)
if recovers:
lines += ['', '_Opened automatically by Gandalf. It adds a note here when the problem clears, '
'but leaves closing the ticket to you._']
else:
lines += ['', '_Reported automatically by Gandalf. This already happened, so there will be no '
'recovery note._']
return '\n'.join(lines)
def history_lines(stats: dict, now: datetime) -> List[str]:
week, month = stats.get('last_7d', 0), stats.get('last_30d', 0)
if not month:
lines = ['- First time in the last 30 days.']
else:
lines = [f'- Happened {week} time{"s" if week != 1 else ""} in the last 7 days '
f'and {month} in the last 30 (not counting this one).']
if week >= 3:
lines.append('- **This keeps coming back**: look for a cause that comes and goes '
'(a loose cable, a failing optic, power, or a scheduled job).')
first, resolved = stats.get('last_first_seen'), stats.get('last_resolved_at')
if resolved:
took = duration((resolved - first).total_seconds()) if first else 'unknown'
ago = duration((now - resolved).total_seconds())
lines.append(f'- Last cleared {utc(resolved)} ({ago} ago), after {took}.')
return lines
ISSUE_FIXED = {
'cable_mismatch': 'The cable now matches the cutsheet (or the cutsheet was updated).',
'monitor_source_unavailable': 'Prometheus is returning data again; host and interface alerting has resumed.',
}
def recovery_comment(event: dict, now: datetime, url: str = '') -> str:
"""The note Gandalf adds to a ticket when its alert clears."""
first, resolved = event.get('first_seen'), event.get('resolved_at') or now
target = event['target_name'] + (f' {event["target_detail"]}' if event.get('target_detail') else '')
lines = [f'**✅ Cleared**: {event["event_type"].replace("_", " ")} on {target}.', '']
lines.append(f'- **Cleared:** {utc(resolved)}')
if first:
lines.append(f'- **Lasted:** {duration((resolved - first).total_seconds())} '
f'(first seen {utc(first)})')
if event.get('consecutive_failures'):
lines.append(f'- **Failed checks:** {event["consecutive_failures"]}')
if url:
lines.append(f'- **Gandalf:** {url}')
lines += ['', ISSUE_FIXED.get(event['event_type'], 'Gandalf no longer sees the problem.')]
lines += ['', '_Gandalf leaves this ticket open. Close it once you know why it happened, '
'or leave it open if it needs follow-up._']
return '\n'.join(lines)