Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
3afd85626b | ||
|
|
c2ff072eb2 | ||
|
|
f097e4882c | ||
|
|
0370358363 | ||
|
|
2a9111d8e8 | ||
|
|
de75f71bf8 | ||
|
|
2f4cb05f67 | ||
|
|
fa108b2a1e | ||
|
|
ff425dbaee | ||
|
|
99dee62098 | ||
|
|
4ad331ddfe | ||
|
|
7da4cc26e2 | ||
|
|
73787daaec | ||
|
|
6a717af3f2 | ||
|
|
f1355c4bd8 | ||
|
|
abac6983b2 | ||
|
|
4646d9be90 | ||
|
|
c535bfd9fb | ||
|
|
a90ce44c80 | ||
|
|
4dfabce2fb | ||
|
|
d6fcddb6fc | ||
|
|
ce68d592c3 | ||
|
|
3a1371e8b7 | ||
|
|
60d892badb | ||
|
|
206175df39 | ||
|
|
b9e008bc2b | ||
|
|
ab59b42bea | ||
|
|
415d2222e7 | ||
|
|
dcf5fdf4cc | ||
|
|
20822d000e | ||
|
|
7dba1750ee | ||
|
|
abe88df3a4 | ||
|
|
aa7341af06 | ||
|
|
390748173c | ||
|
|
64eba37f81 | ||
|
|
0631de74c7 | ||
|
|
0921e82c54 | ||
|
|
7b80633088 | ||
|
|
379e3be365 | ||
|
|
6b03fe7b44 | ||
|
|
3834546f38 | ||
|
|
aeb7a89e81 | ||
|
|
9bdf5d9eed | ||
|
|
cbdae54d70 | ||
|
|
36cbdd061d | ||
|
|
6e6150f9b9 | ||
|
|
d234e36e3f | ||
|
|
7408b1feca | ||
|
|
64ef4222d0 | ||
|
|
fde1d01f27 | ||
|
|
8edaa78ad7 | ||
|
|
3bc8df6dc7 | ||
|
|
d8e827c88b | ||
|
|
a0e062493d | ||
|
|
d07787ee38 | ||
|
|
7e75ba8b3c | ||
|
|
0243b23732 | ||
|
|
90e051dc22 | ||
|
|
486a93c5a0 | ||
|
|
a9de175d90 | ||
|
|
ce12dede5f | ||
|
|
6530433d9c | ||
|
|
5fdd317539 | ||
|
|
3e2918526f | ||
|
|
50db56cdcb | ||
|
|
619a2c913d | ||
|
|
3c9e5fd593 | ||
|
|
565fdd81de | ||
|
|
0f4e129c20 | ||
|
|
b416239438 | ||
|
|
97e6692ebf | ||
|
|
bee260f1cd | ||
|
|
c50e1f8322 | ||
|
|
cd3d2f05ee | ||
|
|
bdd68a397d | ||
|
|
4f353888f8 | ||
|
|
f655836446 | ||
|
|
ee2708dccb | ||
|
|
c262e5ecc8 | ||
|
|
29119c2235 | ||
|
|
9d561db703 | ||
|
|
9e2a2b987c | ||
|
|
437f7a415f | ||
|
|
ff0094c8ff | ||
|
|
86aa29b378 | ||
|
|
cd602fdacf | ||
|
|
52cfea5439 | ||
|
|
b9412ff6ba | ||
|
|
afc7aae580 | ||
|
|
7e588e5b02 | ||
|
|
085c488f7b | ||
|
|
5c4e4dc099 | ||
|
|
93828b38e9 | ||
|
|
178a03e898 | ||
|
|
7c917969d8 | ||
|
|
051e70b82b | ||
|
|
d6263049ef | ||
|
|
bdcfb76c25 | ||
|
|
e32499b7f6 | ||
|
|
e1716d5228 | ||
|
|
4a1998046b | ||
|
|
fed279a0bd | ||
|
|
e0ff3e2168 | ||
|
|
c64853f643 | ||
|
|
42cf754796 | ||
|
|
28fd5aad14 | ||
|
|
65536d58c5 | ||
|
|
0e852ebd11 | ||
|
|
8aaaa89f03 | ||
|
|
7467236ffd | ||
|
|
dc16a583a5 | ||
|
|
12ef20901a | ||
|
|
0693ad56f9 | ||
|
|
c455c5d4b9 | ||
|
|
13e6839cdf | ||
|
|
e7c83eff2b | ||
|
|
5c2a92eaee | ||
|
|
f942e96c24 | ||
|
|
8173b9dc7f | ||
|
|
2896692d93 | ||
|
|
c2492bbfe8 | ||
|
|
33b214eac0 | ||
|
|
0331c2bd00 | ||
|
|
2710eaa118 | ||
|
|
9c011cfce1 | ||
|
|
182cc8c451 | ||
|
|
0d4f209c79 | ||
|
|
b3495caac8 | ||
|
|
ac7f406175 | ||
|
|
124ca10bb0 | ||
|
|
18066ef062 | ||
|
|
160dfdfd79 | ||
|
|
e0452193ee | ||
|
|
41c350815a | ||
|
|
72651e5d33 | ||
|
|
a28533946e | ||
|
|
d3616badb2 | ||
|
|
705d06ca5b | ||
|
|
1daa9ab475 | ||
|
|
17d273d792 | ||
|
|
088ba789c9 | ||
|
|
60c7c27ac7 | ||
|
|
b0817e2582 | ||
|
|
80587bbbc4 | ||
|
|
18ab78c35a | ||
|
|
68f69e1539 | ||
|
|
8e9a6b9b3f | ||
|
|
872dbf3b48 | ||
|
|
ff2c0bd90a | ||
|
|
5ee7154c45 | ||
|
|
d63f73e90f | ||
|
|
bc71cc829b | ||
|
|
c3f0fcbefb | ||
|
|
d8a4474814 | ||
|
|
9e0f8555cc | ||
|
|
f25a377968 | ||
|
|
7abb76afaa | ||
|
|
6e3a579956 | ||
|
|
332f041e05 | ||
|
|
66c2c6bc5f | ||
|
|
ddc258a453 | ||
|
|
e6649a4c39 | ||
|
|
f0759ed24c | ||
|
|
9d15d4b802 | ||
|
|
6f9787b74a | ||
|
|
032d0db81e | ||
|
|
5fdb77d664 | ||
|
|
d05deb6ccd | ||
|
|
3a9cc472e1 | ||
|
|
54369bf6c3 | ||
|
|
a5fcd619f8 | ||
|
|
1767c12f1b | ||
|
|
6461afe12f | ||
|
|
6473d932a7 | ||
|
|
b31b5dd122 | ||
|
|
1e9ce08dca | ||
|
|
c0f8975dee | ||
|
|
51c18fee5c | ||
|
|
b61501d81d | ||
|
|
3e36dc9505 | ||
|
|
0d4f792a46 | ||
|
|
9dc10422e3 | ||
|
|
903dc960c3 | ||
|
|
6880abdff3 | ||
|
|
a4fd74754c | ||
|
|
5c3db5e934 | ||
|
|
3aff52f972 | ||
|
|
de5677fe4d | ||
|
|
eb9fb3f88f | ||
|
|
44d4a7d1eb | ||
|
|
ee0ea8fd47 | ||
|
|
95ec211037 | ||
|
|
253bc568d6 | ||
|
|
892d1cfe2d | ||
|
|
834acfd393 | ||
|
|
148fc57cc2 | ||
|
|
35d785db64 | ||
|
|
f3753092e0 | ||
|
|
55989f4c50 | ||
|
|
bc1d3fb33b | ||
|
|
3840d2ccb7 | ||
|
|
df7b7e36e5 | ||
|
|
fb6848b7e0 | ||
|
|
34758768a4 | ||
|
|
a7c3f97252 | ||
|
|
4413bb8b4c | ||
|
|
df2a2cc48c | ||
|
|
c51c24bbb5 | ||
|
|
4ea5ae61e4 | ||
|
|
300b1cc68c | ||
|
|
18112541c8 | ||
|
|
468dbda7a1 | ||
|
|
c8e183fc4f | ||
|
|
124a8c4ea2 | ||
|
|
565bd4ee24 | ||
|
|
150300ff91 | ||
|
|
997c626c3c | ||
|
|
c201604dca | ||
|
|
04a5182259 | ||
|
|
4a66c41d18 | ||
|
|
517843886b | ||
|
|
ec1e8055de | ||
|
|
773802815a | ||
|
|
3688cf6d62 | ||
|
|
c8fb605dbb | ||
|
|
2498388715 | ||
|
|
640a3b9993 | ||
|
|
a7b164f340 | ||
|
|
6f79dc905d | ||
|
|
705be36c3f | ||
|
|
9188401374 | ||
|
|
59546cd080 | ||
|
|
6b0ef3fcb6 | ||
|
|
2b1af750f4 | ||
|
|
361e85fd69 | ||
|
|
b3b118395a | ||
|
|
bc2590dc34 | ||
|
|
df460afe68 | ||
|
|
0438bd32ce | ||
|
|
05671360cd | ||
|
|
f3b9d26ec2 | ||
|
|
27a1707b81 | ||
|
|
dfdafc07c4 | ||
|
|
8c72a1494a | ||
|
|
3115b714aa | ||
|
|
4edffca6af | ||
|
|
231de5714b | ||
|
|
bb2f6b96cf | ||
|
|
d37e58af15 | ||
|
|
4f126f1ffb | ||
|
|
071f5e954d | ||
|
|
646a1c3687 | ||
|
|
0894f35cde | ||
|
|
09823f8619 | ||
|
|
62a4ec16a2 | ||
|
|
bd5707160a | ||
|
|
a21c21fbfc | ||
|
|
786c4be2ff | ||
|
|
1a4ffa107d | ||
|
|
637b9876a3 | ||
|
|
d7b7b1d17a | ||
|
|
b2a183b0e2 | ||
|
|
fa7ec4cfe2 | ||
|
|
0b068c824b | ||
|
|
d4a28b37fb | ||
|
|
21bd5d8dbf | ||
|
|
a35f0527e3 | ||
|
|
d671916100 | ||
|
|
c2cfa6370e | ||
|
|
eefa162863 | ||
|
|
8c81c19785 | ||
|
|
f3eab76c63 | ||
|
|
9e091cd8fe | ||
|
|
5173302eb4 | ||
|
|
d4cdad7006 | ||
|
|
8f73514297 | ||
|
|
21dfad35bf | ||
|
|
81ba85845b | ||
|
|
109dff1cd0 | ||
|
|
a746140e8b |
No files matched your search
@@ -0,0 +1,7 @@
|
||||
[run]
|
||||
omit =
|
||||
tests/*
|
||||
*/site-packages/*
|
||||
|
||||
[report]
|
||||
show_missing = True
|
||||
@@ -0,0 +1,21 @@
|
||||
{
|
||||
"env": {
|
||||
"browser": true,
|
||||
"es2021": true
|
||||
},
|
||||
"globals": {
|
||||
"lt": "readonly",
|
||||
"GANDALF_CONFIG": "readonly",
|
||||
"CSS": "readonly"
|
||||
},
|
||||
"rules": {
|
||||
"no-undef": "error",
|
||||
"no-unused-vars": ["warn", { "argsIgnorePattern": "^_", "varsIgnorePattern": "^_" }],
|
||||
"no-console": "off",
|
||||
"eqeqeq": ["error", "always", { "null": "ignore" }]
|
||||
},
|
||||
"parserOptions": {
|
||||
"ecmaVersion": 2021,
|
||||
"sourceType": "script"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +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
|
||||
extend-ignore = E221, E305
|
||||
exclude = __pycache__, .git, node_modules
|
||||
extend-exclude = node_modules
|
||||
@@ -0,0 +1,86 @@
|
||||
name: Lint
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: ["**"]
|
||||
pull_request:
|
||||
branches: ["**"]
|
||||
|
||||
jobs:
|
||||
python-lint:
|
||||
name: Python (flake8)
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v3
|
||||
|
||||
- name: Install Python and flake8
|
||||
run: |
|
||||
apt-get update -qq
|
||||
apt-get install -y -qq python3 python3-pip
|
||||
pip3 install --break-system-packages flake8
|
||||
|
||||
- name: Run flake8
|
||||
run: flake8 . --exclude=__pycache__,.git
|
||||
|
||||
js-lint:
|
||||
name: JS (eslint)
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v3
|
||||
|
||||
- name: Install ESLint
|
||||
run: npm install --save-dev eslint@8
|
||||
|
||||
- name: Run ESLint
|
||||
run: npx eslint --ext .js static/
|
||||
|
||||
notify-failure:
|
||||
name: Notify on failure
|
||||
runs-on: ubuntu-latest
|
||||
needs: [python-lint, js-lint]
|
||||
if: failure() && github.event_name == 'push'
|
||||
steps:
|
||||
- name: Send Matrix alert
|
||||
env:
|
||||
MATRIX_WEBHOOK_URL: ${{ secrets.MATRIX_WEBHOOK_URL }}
|
||||
REPO: ${{ github.repository }}
|
||||
BRANCH: ${{ github.ref_name }}
|
||||
RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
|
||||
run: |
|
||||
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}\"}"
|
||||
|
||||
deploy:
|
||||
name: Deploy
|
||||
runs-on: ubuntu-latest
|
||||
needs: [python-lint, js-lint]
|
||||
if: github.event_name == 'push' && github.ref == 'refs/heads/main'
|
||||
permissions:
|
||||
contents: write
|
||||
steps:
|
||||
- name: Trigger webhook
|
||||
env:
|
||||
WEBHOOK_SECRET: ${{ secrets.WEBHOOK_SECRET }}
|
||||
GIT_REF: ${{ github.ref }}
|
||||
run: |
|
||||
PAYLOAD="{\"ref\":\"${GIT_REF}\"}"
|
||||
SIG=$(echo -n "$PAYLOAD" | openssl dgst -sha256 -hmac "$WEBHOOK_SECRET" | awk '{print $2}')
|
||||
curl -sf --connect-timeout 10 \
|
||||
-X POST \
|
||||
-H "Content-Type: application/json" \
|
||||
-H "X-Gitea-Signature: ${SIG}" \
|
||||
-d "$PAYLOAD" \
|
||||
"http://10.10.10.61:9000/hooks/gandalf-deploy"
|
||||
|
||||
- name: Tag deployed commit
|
||||
env:
|
||||
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
run: |
|
||||
TAG="deploy-$(date -u +%Y.%m.%d)-${{ github.run_number }}"
|
||||
curl -sf -X POST \
|
||||
-H "Authorization: token $GITHUB_TOKEN" \
|
||||
-H "Content-Type: application/json" \
|
||||
-d "{\"tag_name\":\"${TAG}\",\"target\":\"${{ github.sha }}\",\"message\":\"Deployed to production\"}" \
|
||||
"https://code.lotusguild.org/api/v1/repos/${{ github.repository }}/tags"
|
||||
@@ -0,0 +1,25 @@
|
||||
name: Security
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: ["**"]
|
||||
pull_request:
|
||||
branches: ["**"]
|
||||
schedule:
|
||||
- cron: '0 6 * * 1'
|
||||
|
||||
jobs:
|
||||
bandit:
|
||||
name: Python Security (bandit)
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v3
|
||||
|
||||
- name: Install bandit
|
||||
run: |
|
||||
apt-get update -qq
|
||||
apt-get install -y -qq python3 python3-pip
|
||||
pip3 install --break-system-packages bandit
|
||||
|
||||
- name: Run bandit
|
||||
run: bandit -r . --exclude .git,__pycache__,node_modules -ll
|
||||
@@ -0,0 +1,24 @@
|
||||
name: Test
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: ["**"]
|
||||
pull_request:
|
||||
branches: ["**"]
|
||||
|
||||
jobs:
|
||||
pytest:
|
||||
name: Python Tests (pytest)
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v3
|
||||
|
||||
- name: Install Python and dependencies
|
||||
run: |
|
||||
apt-get update -qq
|
||||
apt-get install -y -qq python3 python3-pip
|
||||
pip3 install --break-system-packages pytest pytest-cov
|
||||
pip3 install --break-system-packages -r requirements.txt --quiet
|
||||
|
||||
- name: Run pytest with coverage
|
||||
run: python3 -m pytest tests/ -v --cov=. --cov-report=term-missing --cov-config=.coveragerc
|
||||
@@ -0,0 +1,5 @@
|
||||
log.txt
|
||||
config.json
|
||||
__pycache__/
|
||||
*.pyc
|
||||
node_modules/
|
||||
|
Before Width: | Height: | Size: 58 KiB |
|
Before Width: | Height: | Size: 49 KiB |
|
Before Width: | Height: | Size: 84 KiB |
@@ -0,0 +1,21 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2025-2026 Jared Vititoe
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
@@ -0,0 +1,215 @@
|
||||
"""What needs looking at, gathered from every page into one list for the dashboard.
|
||||
|
||||
Two groups: 'broken' is something not working right now; 'tidy' is housekeeping, where
|
||||
the network works but the records or names don't match it. Each entry links to the page
|
||||
where it is fixed. Pure functions, so the rules are easy to test.
|
||||
"""
|
||||
import time
|
||||
from typing import Dict, List, Optional
|
||||
|
||||
import modem
|
||||
|
||||
GROUPS = ('broken', 'tidy')
|
||||
|
||||
|
||||
def _plural(n: int, one: str, many: Optional[str] = None) -> str:
|
||||
return f'{n} {one if n == 1 else (many or one + "s")}'
|
||||
|
||||
|
||||
def _entry(group: str, severity: str, text: str, href: str, detail: str = '') -> dict:
|
||||
return {'group': group, 'severity': severity, 'text': text, 'href': href, 'detail': detail}
|
||||
|
||||
|
||||
def _alerts(events: List[dict]) -> List[dict]:
|
||||
live = [e for e in events if not e.get('is_suppressed') and e.get('severity') != 'info']
|
||||
if not live:
|
||||
return []
|
||||
critical = sum(1 for e in live if e.get('severity') == 'critical')
|
||||
targets = sorted({str(e.get('target_name') or '') for e in live if e.get('target_name')}, key=str.lower)
|
||||
text = _plural(len(live), 'active alert')
|
||||
if critical:
|
||||
text += f' ({critical} critical)'
|
||||
shown = ', '.join(targets[:4]) + (f' and {len(targets) - 4} more' if len(targets) > 4 else '')
|
||||
return [_entry('broken', 'bad' if critical else 'warn', text, '#events-table-wrap', shown)]
|
||||
|
||||
|
||||
def _power(power: List[dict]) -> List[dict]:
|
||||
out = []
|
||||
for src in power or []:
|
||||
name = src.get('node') or ''
|
||||
if src.get('stale_since'):
|
||||
out.append(_entry('broken', 'warn', f'{name}: outlet watts are frozen', '/topology',
|
||||
'UniFi keeps sending the same per-outlet readings; the total is still live. '
|
||||
'Restarting the unit usually clears it.'))
|
||||
for o in src.get('outlets') or []:
|
||||
if not o.get('on') and o.get('target'):
|
||||
out.append(_entry('broken', 'bad', f'{name} outlet {o.get("index")} is off, and it feeds {o["target"]}',
|
||||
'/topology'))
|
||||
idle = []
|
||||
for src in power or []:
|
||||
for o in src.get('outlets') or []:
|
||||
# Drawing real power, but nothing in Gandalf says what is plugged in
|
||||
if o.get('on') and not o.get('target') and o.get('match') != 'cleared' and (o.get('power_w') or 0) >= 5:
|
||||
idle.append(f'{src.get("node")} {o.get("index")}')
|
||||
if idle:
|
||||
out.append(_entry('tidy', 'info', f'{_plural(len(idle), "powered outlet")} with no device assigned',
|
||||
'/topology', ', '.join(idle[:6]) + (' ...' if len(idle) > 6 else '')))
|
||||
return out
|
||||
|
||||
|
||||
def _cutsheet(view: dict) -> List[dict]:
|
||||
out = []
|
||||
cables = [c for c in view.get('cables') or [] if c.get('status') != 'retired']
|
||||
bad = [c for c in cables if c.get('problem')]
|
||||
if bad:
|
||||
names = ', '.join(c.get('label') or f'#{c["id"]}' for c in bad[:5])
|
||||
out.append(_entry('broken', 'bad', f'{_plural(len(bad), "cable")} not where the cutsheet says',
|
||||
'/cutsheet?problems=1#cs-cables-section', names))
|
||||
|
||||
names = view.get('port_names') or []
|
||||
wrong = [r for r in names if r.get('kind') in ('wrong', 'moved')]
|
||||
if wrong:
|
||||
out.append(_entry('tidy', 'warn', f'{_plural(len(wrong), "UniFi port name")} pointing at the wrong device',
|
||||
'/cutsheet#cs-portnames-section',
|
||||
', '.join(f'{r["switch"]} port {r["port_idx"]} "{r["port_name"]}"' for r in wrong[:3])))
|
||||
empty = [r for r in names if r.get('kind') == 'empty']
|
||||
if empty:
|
||||
out.append(_entry('tidy', 'info', f'{_plural(len(empty), "named port")} with nothing plugged in',
|
||||
'/cutsheet#cs-portnames-section',
|
||||
', '.join(f'"{r["port_name"]}"' for r in empty[:4])))
|
||||
|
||||
missing = view.get('suggestions') or []
|
||||
if missing:
|
||||
out.append(_entry('tidy', 'info', f'{_plural(len(missing), "live link")} not on the cutsheet',
|
||||
'/cutsheet#cs-suggest-section'))
|
||||
|
||||
labels = view.get('labels') or {}
|
||||
todo = len(labels.get('cables') or []) + len(labels.get('ports') or [])
|
||||
if todo:
|
||||
out.append(_entry('tidy', 'info', f'{_plural(todo, "label")} to print and stick on',
|
||||
'/cutsheet#cs-labels-section'))
|
||||
return out
|
||||
|
||||
|
||||
def _rack(issues: Dict[str, dict]) -> List[dict]:
|
||||
out = []
|
||||
for rack, r in (issues or {}).items():
|
||||
for o in r.get('overlaps') or []:
|
||||
out.append(_entry('tidy', 'warn', f'{o["name"]} overlaps {", ".join(o["with"])} at {o["units"]}',
|
||||
'/cutsheet#cs-items-section', rack))
|
||||
for o in r.get('outside') or []:
|
||||
out.append(_entry('tidy', 'warn', f'{o["name"]} at {o["units"]} is outside {rack}',
|
||||
'/cutsheet#cs-items-section'))
|
||||
return out
|
||||
|
||||
|
||||
# UniFi's WAN timeline: judge the last hour, and ignore a copy the monitor stopped refreshing
|
||||
_WAN_WINDOW_S = 3600
|
||||
_WAN_STALE_S = 1800
|
||||
_WAN_BAD_PERIODS = 3 # periods with any problem before the list mentions it
|
||||
_WAN_LOSS_PERIODS = 2 # periods with packet loss before it counts as broken
|
||||
|
||||
|
||||
def _ago(seconds: float) -> str:
|
||||
minutes = max(1, round(seconds / 60))
|
||||
return f'{minutes} min ago' if minutes < 60 else f'{round(minutes / 60)} h ago'
|
||||
|
||||
|
||||
_NAT_FULL = 0.8 # share of the gateway's NAT sessions in use before it's worth a line
|
||||
|
||||
|
||||
def _modem_ping_note(checks: Optional[dict], now: float) -> str:
|
||||
"""One sentence on the latest ping from the modem itself, if it ran in the last hour."""
|
||||
ping = (checks or {}).get('ping') or {}
|
||||
if not ping or now - (ping.get('at') or 0) > _WAN_WINDOW_S:
|
||||
return ''
|
||||
when, avg, ours = _ago(now - ping['at']), ping.get('avg_ms'), ping.get('ours_ms')
|
||||
theirs = (f'{round(avg)} ms' if avg is not None else 'no reply') + (
|
||||
f', {ping["loss_pct"]}% lost' if ping.get('loss_pct') else '')
|
||||
ours_txt = f'; ours through it {round(ours)} ms' if ours is not None else ''
|
||||
verdict = {
|
||||
'upstream': "so the delay is past the modem, on the provider's side",
|
||||
'gateway': 'so the delay is in the modem, or between it and the router',
|
||||
'clear': 'both fine by then',
|
||||
}.get(ping.get('verdict'), '')
|
||||
return f"Modem's own ping {when}: {theirs}{ours_txt}, {verdict}. "
|
||||
|
||||
|
||||
def _modem_checks(checks: Optional[dict]) -> List[dict]:
|
||||
out = []
|
||||
nat = (checks or {}).get('nat') or {}
|
||||
if nat.get('available') and nat.get('in_use', 0) / nat['available'] >= _NAT_FULL:
|
||||
pct = round(100 * nat['in_use'] / nat['available'])
|
||||
out.append(_entry('broken', 'warn', f'Modem NAT table {pct}% full',
|
||||
'#modem-section', f'{nat["in_use"]:,} of {nat["available"]:,} sessions in use. '
|
||||
'When it fills, new connections stall or fail.'))
|
||||
error = (checks or {}).get('error') or {}
|
||||
if error.get('login'):
|
||||
out.append(_entry('tidy', 'warn', 'Modem login failed: check modem.access_code in config.json',
|
||||
'#modem-section', 'Gandalf waits 30 minutes before trying again.'))
|
||||
return out
|
||||
|
||||
|
||||
def _wan(quality: Optional[dict], now: float, checks: Optional[dict] = None) -> List[dict]:
|
||||
if not quality or now - (quality.get('updated') or 0) > _WAN_STALE_S:
|
||||
return []
|
||||
out = []
|
||||
periods = quality.get('periods') or []
|
||||
# The last hour is the newest 12 periods (each stamped with its start), so the count
|
||||
# doesn't dip while UniFi is still filling in the current one
|
||||
newest = periods[-1]['ts'] if periods else now
|
||||
recent = modem.quality_counts(periods, newest - _WAN_WINDOW_S + modem.QUALITY_PERIOD_S)
|
||||
total = sum(recent.values())
|
||||
bad = total - recent['ok']
|
||||
day = modem.quality_counts(periods, now - 86400)
|
||||
day_bad = sum(day.values()) - day['ok']
|
||||
latencies = quality.get('latencies') or {}
|
||||
detail = (f'UniFi flagged {day_bad} of the last {sum(day.values())} five-minute periods. '
|
||||
if day_bad else '')
|
||||
if latencies:
|
||||
detail += 'Now: ' + ', '.join(f'{k} {v} ms' for k, v in sorted(latencies.items())) + '. '
|
||||
detail += _modem_ping_note(checks, now)
|
||||
detail += 'See the 24 hour strip on the WAN / Fiber panel.'
|
||||
lossy = recent['loss'] + recent['down']
|
||||
if lossy >= _WAN_LOSS_PERIODS:
|
||||
out.append(_entry('broken', 'bad', f'Internet: packet loss in {lossy} of the last {total} '
|
||||
'five-minute periods', '#modem-section', detail))
|
||||
elif bad >= _WAN_BAD_PERIODS:
|
||||
out.append(_entry('broken', 'warn', f'Internet: high latency in {bad} of the last {total} '
|
||||
'five-minute periods', '#modem-section', detail))
|
||||
drops = [d for d in quality.get('downtime') or [] if d['ts'] >= now - _WAN_WINDOW_S]
|
||||
if len(drops) == 1:
|
||||
out.append(_entry('broken', 'warn', f'Internet dropped for {round(drops[0]["seconds"])} s, '
|
||||
f'{_ago(now - drops[0]["ts"])}', '#modem-section'))
|
||||
elif drops:
|
||||
out.append(_entry('broken', 'warn', f'Internet dropped {len(drops)} times in the last hour, '
|
||||
f'{round(sum(d["seconds"] for d in drops))} s in all',
|
||||
'#modem-section'))
|
||||
return out
|
||||
|
||||
|
||||
def build(events: List[dict], power: List[dict], cutsheet_view: Optional[dict],
|
||||
rack_issues: Optional[Dict[str, dict]] = None, wan_quality: Optional[dict] = None,
|
||||
now: Optional[float] = None, modem_checks: Optional[dict] = None) -> dict:
|
||||
"""{'broken': [entry], 'tidy': [entry]}, worst first within each group.
|
||||
|
||||
events: active alerts, annotated with 'is_suppressed'. power: topology.build_power output.
|
||||
cutsheet_view: the cutsheet API view (cables with 'problem', suggestions, port_names,
|
||||
labels), or None when the cutsheet couldn't be loaded. rack_issues: {rack: rack_layout()}.
|
||||
wan_quality: modem.wan_quality() output as stored by the monitor. modem_checks: the
|
||||
monitor's logged-in modem checks (NAT sessions, ping from the modem). now: for tests.
|
||||
Entry: {group, severity: bad|warn|info, text, href, detail}.
|
||||
"""
|
||||
now = time.time() if now is None else now
|
||||
entries = (_wan(wan_quality, now, modem_checks) + _modem_checks(modem_checks)
|
||||
+ _alerts(events) + _power(power))
|
||||
if cutsheet_view is not None:
|
||||
entries += _cutsheet(cutsheet_view)
|
||||
entries += _rack(rack_issues or {})
|
||||
rank = {'bad': 0, 'warn': 1, 'info': 2}
|
||||
out = {g: [] for g in GROUPS}
|
||||
for e in entries:
|
||||
out[e['group']].append(e)
|
||||
for g in GROUPS:
|
||||
out[g].sort(key=lambda e: rank[e['severity']])
|
||||
return out
|
||||
@@ -0,0 +1,84 @@
|
||||
{
|
||||
"pulse": {
|
||||
"url": "http://10.10.10.65:8080",
|
||||
"api_key": "012b303a324152c509bf5ade6f942cfc21404f68662f01a17001cba9e4486049",
|
||||
"worker_id": "1b11d1b5-4ed0-42df-a6af-8d57fffe1343",
|
||||
"timeout": 45
|
||||
},
|
||||
"unifi": {
|
||||
"controller": "https://10.10.10.1",
|
||||
"api_key": "kyPfIsAVie3hwMD4Bc1MjAu8N7HVPIb8",
|
||||
"site_id": "default"
|
||||
},
|
||||
"prometheus": {
|
||||
"url": "http://10.10.10.48:9090"
|
||||
},
|
||||
"database": {
|
||||
"host": "10.10.10.50",
|
||||
"port": 3306,
|
||||
"user": "gandalf",
|
||||
"password": "Gandalf2026Lotus",
|
||||
"name": "gandalf"
|
||||
},
|
||||
"ticket_api": {
|
||||
"url": "http://10.10.10.45/create_ticket_api.php",
|
||||
"api_key": "5acc5d3c647b84f7c6f59082ce4450ee772e2d1633238b960136f653d20c93af"
|
||||
},
|
||||
"ldap": {
|
||||
"host": "10.10.10.39",
|
||||
"port": 3890,
|
||||
"bind_dn": "uid=gandalf,ou=people,dc=example,dc=com",
|
||||
"bind_pw": "AZ-eUFRxamnlLEELuDy5-Mh6z-2cJbL_YJZnu64Tf0A",
|
||||
"user_base": "ou=people,dc=example,dc=com",
|
||||
"cache_dir": "/tmp/gandalf_avatars",
|
||||
"cache_ttl": 3600
|
||||
},
|
||||
"auth": {
|
||||
"allowed_groups": ["admin"]
|
||||
},
|
||||
"monitor": {
|
||||
"poll_interval": 300,
|
||||
"failure_threshold": 2,
|
||||
"unifi_failure_threshold": 4,
|
||||
"cluster_threshold": 3,
|
||||
"ping_hosts": [],
|
||||
"links_exclude_ips": ["10.10.10.29", "10.10.10.44", "10.10.10.3"]
|
||||
},
|
||||
"hosts": [
|
||||
{
|
||||
"name": "pbs",
|
||||
"ip": "10.10.10.3",
|
||||
"prometheus_instance": "10.10.10.3:9100"
|
||||
},
|
||||
{
|
||||
"name": "large1",
|
||||
"ip": "10.10.10.2",
|
||||
"prometheus_instance": "10.10.10.2:9100"
|
||||
},
|
||||
{
|
||||
"name": "compute-storage-01",
|
||||
"ip": "10.10.10.4",
|
||||
"prometheus_instance": "10.10.10.4:9100"
|
||||
},
|
||||
{
|
||||
"name": "monitor-01",
|
||||
"ip": "10.10.10.8",
|
||||
"prometheus_instance": "10.10.10.8:9100"
|
||||
},
|
||||
{
|
||||
"name": "monitor-02",
|
||||
"ip": "10.10.10.9",
|
||||
"prometheus_instance": "10.10.10.9:9100"
|
||||
},
|
||||
{
|
||||
"name": "compute-storage-gpu-01",
|
||||
"ip": "10.10.10.10",
|
||||
"prometheus_instance": "10.10.10.10:9100"
|
||||
},
|
||||
{
|
||||
"name": "storage-01",
|
||||
"ip": "10.10.10.11",
|
||||
"prometheus_instance": "10.10.10.11:9100"
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,705 @@
|
||||
"""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')
|
||||
# Which way an item's ports face. Gear on the rear posts usually still faces the front.
|
||||
FACINGS = ('front', 'rear')
|
||||
# Rack views: the front posts seen from the front, the rear posts seen from the front
|
||||
# (what is behind the front gear), and the rack seen from behind
|
||||
RACK_VIEWS = ('front', 'behind', 'rear')
|
||||
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)',
|
||||
'usw-pro-max-24-poe': 'UniFi Switch Pro Max 24 PoE (until UniFi reports it)',
|
||||
'usw-pro-max-48-poe': 'UniFi Switch Pro Max 48 PoE (until UniFi reports it)',
|
||||
'sliger-cx4712': 'Sliger CX4712 4U (10-bay, faceplate off)',
|
||||
'sliger-cx4712-red': 'Sliger CX4712 4U, red front',
|
||||
'sliger-cx4712-white': 'Sliger CX4712 4U, white front',
|
||||
'sliger-cx4712-blue': 'Sliger CX4712 4U, blue front',
|
||||
'uacc-brush-1u': 'UniFi Rack Panel Brush 1U (UACC-Rack-Panel-Brush-1U)',
|
||||
'rosewill-rsv-l4500u': 'Rosewill RSV-L4500U 4U (15-bay)',
|
||||
'zimaboard-832': 'IceWhale ZimaBoard 832 (shelf gear)',
|
||||
'zimaboard-832-cx3': 'IceWhale ZimaBoard 832 + ConnectX-3 SFP+ in PCIe (shelf gear)',
|
||||
'resting': 'No shelf: gear resting on what is below (for a shelf item)',
|
||||
'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),
|
||||
'facing': _text(data, 'facing', 10) or 'front',
|
||||
'slot': _int(data, 'slot', 1, 99, 'Position on the shelf'),
|
||||
'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['facing'] not in FACINGS:
|
||||
raise ValidationError(f'facing must be one of {", ".join(FACINGS)}')
|
||||
if item['slot'] and not item['shelf']:
|
||||
raise ValidationError('A position applies only to an item on a shelf')
|
||||
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'
|
||||
item['facing'] = '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, for one view.
|
||||
|
||||
Front-post and rear-post items may share a unit; full-depth items take it on both.
|
||||
Views (RACK_VIEWS): 'front' shows the front posts from the front; 'behind' shows the
|
||||
rear posts from the front (what sits behind the front gear); 'rear' shows the rear posts
|
||||
from behind. Full-depth items appear in all three.
|
||||
An item that would share a unit and post with one already placed, or runs past the
|
||||
top of the rack, is reported (whatever the view) rather than drawn over another.
|
||||
Returns {'placed': [item + 'rack_top' + 'through'], 'overlaps': [{'name', 'units', 'with'}],
|
||||
'outside': [name]}, where 'through' marks an item seen from the side it doesn't face
|
||||
(its back, rather than its ports).
|
||||
"""
|
||||
side = 'front' if face == 'front' else 'rear'
|
||||
looking = 'rear' if face == 'rear' else 'front'
|
||||
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 side in sides:
|
||||
placed.append(dict(item, rack_top=high, through=(item.get('facing') or 'front') != looking))
|
||||
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
|
||||
@@ -0,0 +1,241 @@
|
||||
"""Device inventory built from the monitor's cached state.
|
||||
|
||||
Pure functions with no I/O: app.py passes in the JSON blobs the monitor stored,
|
||||
so search and the per-device pages always agree about what a device is.
|
||||
"""
|
||||
import re
|
||||
from typing import Dict, List, Optional
|
||||
|
||||
# UniFi reports PDUs as switches or APs, so model codes take priority over type.
|
||||
_PDU_MODELS = {'USPPDUP', 'UP6', 'USPDA2B'}
|
||||
_KIND_BY_TYPE = {
|
||||
'usw': 'switch', 'udm': 'router', 'ugw': 'router', 'uxg': 'router',
|
||||
'uap': 'ap', 'usp': 'pdu',
|
||||
}
|
||||
|
||||
|
||||
_VIRTUAL_IFACE = ('lo', 'vmbr', 'bond', 'docker', 'veth', 'tap', 'fwbr', 'fwpr', 'fwln', 'br-', 'virbr', 'wg', 'tun')
|
||||
|
||||
|
||||
def physical_interfaces(name: str, snapshot: dict) -> List[dict]:
|
||||
"""A host's physical NICs in name order, with their state: [{'name', 'up', 'unused'}].
|
||||
|
||||
Drawn fronts light one RJ45 per NIC in this order (first NIC on the leftmost jack).
|
||||
"""
|
||||
ifaces = (((snapshot or {}).get('hosts') or {}).get(name) or {}).get('interfaces') or {}
|
||||
return [{'name': n, 'up': str(state).lower() == 'up', 'unused': str(state).lower() == 'unused'}
|
||||
for n, state in sorted(ifaces.items()) if not n.startswith(_VIRTUAL_IFACE)]
|
||||
|
||||
|
||||
def unifi_kind(unifi_type: str, model: str) -> str:
|
||||
if model in _PDU_MODELS:
|
||||
return 'pdu'
|
||||
return _KIND_BY_TYPE.get((unifi_type or '').lower(), 'device')
|
||||
|
||||
|
||||
def _mac_forms(mac: str) -> List[str]:
|
||||
"""Return a MAC with and without separators, so either spelling is searchable."""
|
||||
return [mac, re.sub(r'[^0-9a-fA-F]', '', mac)] if mac else []
|
||||
|
||||
|
||||
def _search_text(*parts) -> str:
|
||||
flat = []
|
||||
for p in parts:
|
||||
if isinstance(p, (list, tuple, set)):
|
||||
flat.extend(str(x) for x in p if x)
|
||||
elif p:
|
||||
flat.append(str(p))
|
||||
return ' '.join(flat).lower()
|
||||
|
||||
|
||||
def _port_neighbors(ports: dict) -> List[str]:
|
||||
return [p['lldp']['system_name'] for p in ports.values()
|
||||
if (p.get('lldp') or {}).get('system_name')]
|
||||
|
||||
|
||||
def build_index(snapshot: dict, link_stats: dict, modem: Optional[dict]) -> List[dict]:
|
||||
"""Return every known device as {name, kind, status, ip, model, ..., search}."""
|
||||
snapshot = snapshot or {}
|
||||
link_stats = link_stats or {}
|
||||
devices: Dict[str, dict] = {}
|
||||
|
||||
for name, host in (snapshot.get('hosts') or {}).items():
|
||||
link_ifaces = (link_stats.get('hosts') or {}).get(name) or {}
|
||||
ifaces = sorted(set(host.get('interfaces') or {}) | set(link_ifaces))
|
||||
devices[name] = {
|
||||
'name': name, 'kind': 'host', 'status': host.get('status', 'unknown'),
|
||||
'ip': host.get('ip', ''), 'mac': '', 'model': '', 'source': host.get('source', ''),
|
||||
'interface_count': len(ifaces),
|
||||
'search': _search_text(name, host.get('ip'), 'host server', ifaces),
|
||||
}
|
||||
|
||||
# Prometheus also sees hosts that aren't in config.json, e.g. LXC app servers.
|
||||
# They have link stats but no alerting, so their state is reported as unknown.
|
||||
for name, ifaces in (link_stats.get('hosts') or {}).items():
|
||||
if name not in devices:
|
||||
ip = next((i.get('host_ip') for i in ifaces.values() if i.get('host_ip')), '')
|
||||
devices[name] = {
|
||||
'name': name, 'kind': 'host', 'status': 'unknown', 'ip': ip, 'mac': '', 'model': '',
|
||||
'source': 'prometheus', 'interface_count': len(ifaces),
|
||||
'search': _search_text(name, ip, 'host server', list(ifaces)),
|
||||
}
|
||||
|
||||
switches = link_stats.get('unifi_switches') or {}
|
||||
for d in snapshot.get('unifi') or []:
|
||||
name = d.get('name', '')
|
||||
ports = (switches.get(name) or {}).get('ports') or {}
|
||||
kind = unifi_kind(d.get('type', ''), d.get('model', ''))
|
||||
devices[name] = {
|
||||
'name': name, 'kind': kind, 'status': 'up' if d.get('connected') else 'down',
|
||||
'ip': d.get('ip', ''), 'mac': d.get('mac', ''), 'model': d.get('model', ''),
|
||||
'source': 'unifi', 'interface_count': len(ports),
|
||||
'search': _search_text(
|
||||
name, d.get('ip'), _mac_forms(d.get('mac', '')), d.get('model'),
|
||||
d.get('type'), kind, list(ports), _port_neighbors(ports),
|
||||
),
|
||||
}
|
||||
|
||||
# A switch can have link stats while the device list is unavailable this cycle.
|
||||
for name, sw in switches.items():
|
||||
if name not in devices:
|
||||
ports = sw.get('ports') or {}
|
||||
devices[name] = {
|
||||
'name': name, 'kind': unifi_kind('usw', sw.get('model', '')), 'status': 'unknown',
|
||||
'ip': sw.get('ip', ''), 'mac': '', 'model': sw.get('model', ''),
|
||||
'source': 'unifi', 'interface_count': len(ports),
|
||||
'search': _search_text(name, sw.get('ip'), sw.get('model'), list(ports), _port_neighbors(ports)),
|
||||
}
|
||||
|
||||
if modem and modem.get('name'):
|
||||
name = modem['name']
|
||||
if not modem.get('reachable'):
|
||||
status = 'unknown'
|
||||
else:
|
||||
status = 'down' if modem.get('wan_problems') else 'up'
|
||||
devices[name] = {
|
||||
'name': name, 'kind': 'modem', 'status': status,
|
||||
'ip': modem.get('lan_ip', ''), 'mac': '', 'model': modem.get('model', ''),
|
||||
'source': 'modem', 'interface_count': 0,
|
||||
'search': _search_text(
|
||||
name, modem.get('lan_ip'), modem.get('wan_ip'), modem.get('model'),
|
||||
'modem gateway fiber wan at&t att',
|
||||
),
|
||||
}
|
||||
|
||||
return sorted(devices.values(), key=lambda d: d['name'].lower())
|
||||
|
||||
|
||||
_MAC_RE = re.compile(r'^[0-9a-f]{2}(:[0-9a-f]{2}){5}$')
|
||||
|
||||
|
||||
def _norm_mac(value: Optional[str]) -> str:
|
||||
mac = (value or '').strip().lower().replace('-', ':')
|
||||
return mac if _MAC_RE.match(mac) else ''
|
||||
|
||||
|
||||
def resolve_lldp_neighbors(
|
||||
switches: dict,
|
||||
host_macs: Dict[str, tuple],
|
||||
device_macs: Dict[str, str],
|
||||
host_ips: Dict[str, str],
|
||||
) -> None:
|
||||
"""Fill in LLDP neighbor names in place.
|
||||
|
||||
UniFi's API reports a neighbor's MAC, port ID, and sometimes management IPs, but no
|
||||
system name. Names come from what Gandalf already knows:
|
||||
|
||||
host_macs: {mac: (host, interface)} from node_network_info
|
||||
device_macs: {mac: device name} from UniFi
|
||||
host_ips: {ip: host}
|
||||
"""
|
||||
for sw in (switches or {}).values():
|
||||
for port in (sw.get('ports') or {}).values():
|
||||
lldp = port.get('lldp')
|
||||
if not lldp or lldp.get('system_name'):
|
||||
continue
|
||||
port_mac = _norm_mac(lldp.get('port_id'))
|
||||
chassis_mac = _norm_mac(lldp.get('chassis_id'))
|
||||
if port_mac in host_macs:
|
||||
# The port ID names the exact NIC, so it also gives the interface.
|
||||
lldp['system_name'], lldp['port_id'] = host_macs[port_mac]
|
||||
elif chassis_mac in host_macs:
|
||||
lldp['system_name'] = host_macs[chassis_mac][0]
|
||||
elif chassis_mac in device_macs or port_mac in device_macs:
|
||||
lldp['system_name'] = device_macs.get(chassis_mac) or device_macs[port_mac]
|
||||
else:
|
||||
lldp['system_name'] = next(
|
||||
(host_ips[ip] for ip in lldp.get('mgmt_ips') or [] if ip in host_ips), '',
|
||||
)
|
||||
|
||||
|
||||
def apply_client_locations(
|
||||
switches: dict,
|
||||
clients: List[dict],
|
||||
host_macs: Dict[str, tuple],
|
||||
device_macs: Dict[str, str],
|
||||
) -> None:
|
||||
"""Name server neighbors from UniFi's wired client table, where LLDP gave no name.
|
||||
|
||||
This finds servers that don't run lldpd. Uplink ports are skipped because they
|
||||
carry traffic from devices further downstream.
|
||||
"""
|
||||
for client in clients or []:
|
||||
mac = _norm_mac(client.get('mac'))
|
||||
switch = device_macs.get(_norm_mac(client.get('sw_mac')))
|
||||
if mac not in host_macs or switch not in (switches or {}):
|
||||
continue
|
||||
for port in (switches[switch].get('ports') or {}).values():
|
||||
if port.get('port_idx') != client.get('sw_port') or port.get('is_uplink'):
|
||||
continue
|
||||
if (port.get('lldp') or {}).get('system_name'):
|
||||
continue
|
||||
host, iface = host_macs[mac]
|
||||
port['lldp'] = {
|
||||
'system_name': host, 'port_id': iface, 'chassis_id': mac,
|
||||
'port_desc': '', 'mgmt_ips': [], 'source': 'unifi-clients',
|
||||
}
|
||||
|
||||
|
||||
def uplinks_for_host(name: str, switches: dict) -> List[dict]:
|
||||
"""Find the switch ports whose LLDP neighbor is this host."""
|
||||
found = []
|
||||
for sw_name, sw in (switches or {}).items():
|
||||
for port_name, port in (sw.get('ports') or {}).items():
|
||||
lldp = port.get('lldp') or {}
|
||||
if lldp.get('system_name') == name:
|
||||
found.append({
|
||||
'switch': sw_name, 'port': port_name, 'port_idx': port.get('port_idx'),
|
||||
'host_interface': lldp.get('port_id', ''), 'up': port.get('up', False),
|
||||
'speed_mbps': port.get('speed_mbps', 0),
|
||||
})
|
||||
return found
|
||||
|
||||
|
||||
def device_detail(name: str, snapshot: dict, link_stats: dict, modem: Optional[dict]) -> Optional[dict]:
|
||||
"""Return everything known about one device, or None if it doesn't exist."""
|
||||
match = next((d for d in build_index(snapshot, link_stats, modem) if d['name'] == name), None)
|
||||
if match is None:
|
||||
return None
|
||||
link_stats = link_stats or {}
|
||||
detail = {k: v for k, v in match.items() if k != 'search'}
|
||||
switches = link_stats.get('unifi_switches') or {}
|
||||
|
||||
if match['kind'] == 'host':
|
||||
states = ((snapshot or {}).get('hosts') or {}).get(name, {}).get('interfaces') or {}
|
||||
link_ifaces = (link_stats.get('hosts') or {}).get(name) or {}
|
||||
interfaces = {i: {'state': s} for i, s in states.items()}
|
||||
for iface, stats in link_ifaces.items():
|
||||
interfaces.setdefault(iface, {}).update(stats)
|
||||
detail['interfaces'] = interfaces
|
||||
detail['uplinks'] = uplinks_for_host(name, switches)
|
||||
elif match['kind'] == 'modem':
|
||||
pass # the page renders the shared WAN / Fiber panel from /api/modem
|
||||
else:
|
||||
detail['ports'] = (switches.get(name) or {}).get('ports') or {}
|
||||
# The port panel compares each port with the server on the other end
|
||||
hosts = link_stats.get('hosts') or {}
|
||||
neighbors = set(_port_neighbors(detail['ports']))
|
||||
detail['neighbor_hosts'] = {h: ifaces for h, ifaces in hosts.items() if h in neighbors}
|
||||
detail['info'] = (link_stats.get('unifi_devices') or {}).get(name) or {}
|
||||
detail['updated'] = link_stats.get('updated')
|
||||
return detail
|
||||
@@ -0,0 +1,548 @@
|
||||
"""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.
|
||||
Executed in a background thread; results stored in _diag_jobs (app.py).
|
||||
"""
|
||||
import re
|
||||
import shlex
|
||||
import logging
|
||||
from typing import Dict, List, Optional
|
||||
|
||||
logger = logging.getLogger('gandalf.diagnose')
|
||||
|
||||
# sysfs counters collected per interface
|
||||
_SYSFS_STATS = [
|
||||
'rx_bytes', 'tx_bytes', 'rx_errors', 'tx_errors',
|
||||
'rx_dropped', 'tx_dropped', 'rx_crc_errors',
|
||||
'rx_frame_errors', 'rx_fifo_errors', 'tx_carrier_errors',
|
||||
'collisions', 'rx_missed_errors',
|
||||
]
|
||||
|
||||
|
||||
class DiagnosticsRunner:
|
||||
"""Build and run a link diagnostic against a server NIC via PulseClient."""
|
||||
|
||||
def __init__(self, pulse_client):
|
||||
self.pulse = pulse_client
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# SSH command builder
|
||||
# ------------------------------------------------------------------
|
||||
@staticmethod
|
||||
def build_ssh_command(host_ip: str, iface: str) -> str:
|
||||
"""Return a single-line SSH command that collects all diagnostic data."""
|
||||
q = shlex.quote(iface)
|
||||
ip_q = shlex.quote(host_ip)
|
||||
|
||||
sysfs_loop = '; '.join(
|
||||
f'echo "{s}:$(cat /sys/class/net/{q}/statistics/{s} 2>/dev/null || echo 0)"'
|
||||
for s in _SYSFS_STATS
|
||||
)
|
||||
|
||||
remote_cmd = (
|
||||
f'echo "=== carrier ===";'
|
||||
f' cat /sys/class/net/{q}/carrier 2>/dev/null || echo "?";'
|
||||
f' echo "=== operstate ===";'
|
||||
f' cat /sys/class/net/{q}/operstate 2>/dev/null || echo "?";'
|
||||
f' echo "=== sysfs_stats ===";'
|
||||
f' {sysfs_loop};'
|
||||
f' echo "=== carrier_changes ===";'
|
||||
f' cat /sys/class/net/{q}/carrier_changes 2>/dev/null || echo "0";'
|
||||
f' echo "=== ethtool ===";'
|
||||
f' ethtool {q} 2>/dev/null;'
|
||||
f' echo "=== ethtool_driver ===";'
|
||||
f' ethtool -i {q} 2>/dev/null;'
|
||||
f' echo "=== ethtool_pause ===";'
|
||||
f' ethtool -a {q} 2>/dev/null;'
|
||||
f' echo "=== ethtool_ring ===";'
|
||||
f' ethtool -g {q} 2>/dev/null;'
|
||||
f' echo "=== ethtool_stats ===";'
|
||||
f' ethtool -S {q} 2>/dev/null;'
|
||||
f' echo "=== ethtool_dom ===";'
|
||||
f' ethtool -m {q} 2>/dev/null;'
|
||||
f' echo "=== ip_link ===";'
|
||||
f' ip -s link show {q} 2>/dev/null;'
|
||||
f' echo "=== ip_addr ===";'
|
||||
f' ip addr show {q} 2>/dev/null;'
|
||||
f' echo "=== ip_route ===";'
|
||||
f' ip route show dev {q} 2>/dev/null;'
|
||||
f' echo "=== dmesg ===";'
|
||||
f' dmesg 2>/dev/null | grep -F -- {q} | tail -50;'
|
||||
f' echo "=== lldpctl ===";'
|
||||
f' lldpctl 2>/dev/null || echo "lldpd not running";'
|
||||
f' echo "=== end ==="'
|
||||
)
|
||||
|
||||
return (
|
||||
f'ssh -o StrictHostKeyChecking=accept-new -o ConnectTimeout=5 '
|
||||
f'-o BatchMode=yes -o LogLevel=ERROR '
|
||||
f'-o ServerAliveInterval=10 -o ServerAliveCountMax=2 '
|
||||
f'root@{ip_q} {shlex.quote(remote_cmd)}'
|
||||
)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Main entry point
|
||||
# ------------------------------------------------------------------
|
||||
def run(self, host_ip: str, host_name: str, iface: str,
|
||||
switch_port_data: dict) -> dict:
|
||||
"""Execute diagnostics and return structured result dict."""
|
||||
cmd = self.build_ssh_command(host_ip, iface)
|
||||
logger.info(f'Running link diagnostic: {host_name}/{iface} via Pulse')
|
||||
|
||||
# Reset execution_id before call
|
||||
self.pulse.last_execution_id = None
|
||||
output = self.pulse.run_command(cmd)
|
||||
execution_id = getattr(self.pulse, 'last_execution_id', None)
|
||||
|
||||
if output is None:
|
||||
return {
|
||||
'status': 'error',
|
||||
'error': 'Pulse command failed or timed out',
|
||||
'host': host_name,
|
||||
'iface': iface,
|
||||
'pulse_execution_id': execution_id,
|
||||
}
|
||||
|
||||
sections = self.parse_output(output)
|
||||
health = self.analyze(sections, switch_port_data)
|
||||
|
||||
pulse_url = None
|
||||
if execution_id:
|
||||
base = getattr(self.pulse, 'url', '').rstrip('/')
|
||||
pulse_url = f'{base}/executions/{execution_id}' if base else None
|
||||
|
||||
return {
|
||||
'status': 'done',
|
||||
'host': host_name,
|
||||
'iface': iface,
|
||||
'sections': sections,
|
||||
'health': health,
|
||||
'pulse_execution_id': execution_id,
|
||||
'pulse_url': pulse_url,
|
||||
'switch_port': switch_port_data,
|
||||
}
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Output parser (splits on === SECTION_NAME === sentinels)
|
||||
# ------------------------------------------------------------------
|
||||
@staticmethod
|
||||
def parse_output(raw: str) -> dict:
|
||||
sections: Dict[str, str] = {}
|
||||
current: Optional[str] = None
|
||||
buf: List[str] = []
|
||||
|
||||
for line in raw.splitlines():
|
||||
m = re.match(r'^=== (.+?) ===$', line.strip())
|
||||
if m:
|
||||
if current and current != 'end':
|
||||
sections[current] = '\n'.join(buf).strip()
|
||||
name = m.group(1)
|
||||
if name == 'end':
|
||||
current = None
|
||||
else:
|
||||
current = name
|
||||
buf = []
|
||||
elif current:
|
||||
buf.append(line)
|
||||
|
||||
if current and current != 'end':
|
||||
sections[current] = '\n'.join(buf).strip()
|
||||
|
||||
parsed: dict = {}
|
||||
|
||||
# Simple string sections
|
||||
parsed['carrier'] = sections.get('carrier', '?').strip()
|
||||
parsed['operstate'] = sections.get('operstate', '?').strip()
|
||||
|
||||
# carrier_changes
|
||||
cc_raw = sections.get('carrier_changes', '0').strip()
|
||||
try:
|
||||
parsed['carrier_changes'] = int(cc_raw)
|
||||
except ValueError:
|
||||
parsed['carrier_changes'] = None
|
||||
|
||||
# Structured sections
|
||||
parsed['sysfs_stats'] = DiagnosticsRunner.parse_sysfs_stats(sections.get('sysfs_stats', ''))
|
||||
parsed['ethtool'] = DiagnosticsRunner.parse_ethtool(sections.get('ethtool', ''))
|
||||
parsed['ethtool_driver'] = DiagnosticsRunner.parse_ethtool_driver(sections.get('ethtool_driver', ''))
|
||||
parsed['ethtool_pause'] = DiagnosticsRunner.parse_ethtool_pause(sections.get('ethtool_pause', ''))
|
||||
parsed['ethtool_ring'] = DiagnosticsRunner.parse_ethtool_ring(sections.get('ethtool_ring', ''))
|
||||
parsed['ethtool_stats'] = DiagnosticsRunner.parse_nic_stats(sections.get('ethtool_stats', ''))
|
||||
parsed['ethtool_dom'] = DiagnosticsRunner.parse_ethtool_dom(sections.get('ethtool_dom', ''))
|
||||
parsed['ip_link'] = DiagnosticsRunner.parse_ip_link(sections.get('ip_link', ''))
|
||||
parsed['ip_addr'] = sections.get('ip_addr', '').strip()
|
||||
parsed['ip_route'] = sections.get('ip_route', '').strip()
|
||||
parsed['dmesg'] = DiagnosticsRunner.parse_dmesg(sections.get('dmesg', ''))
|
||||
parsed['lldpctl'] = DiagnosticsRunner.parse_lldpctl(sections.get('lldpctl', ''))
|
||||
|
||||
return parsed
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Individual parsers
|
||||
# ------------------------------------------------------------------
|
||||
@staticmethod
|
||||
def parse_sysfs_stats(text: str) -> dict:
|
||||
result: dict = {}
|
||||
for line in text.splitlines():
|
||||
if ':' not in line:
|
||||
continue
|
||||
key, _, val = line.partition(':')
|
||||
key = key.strip()
|
||||
val = val.strip()
|
||||
if key in _SYSFS_STATS:
|
||||
try:
|
||||
result[key] = int(val)
|
||||
except ValueError:
|
||||
result[key] = 0
|
||||
return result
|
||||
|
||||
@staticmethod
|
||||
def parse_ethtool(text: str) -> dict:
|
||||
"""Parse ethtool <iface> output."""
|
||||
data: dict = {}
|
||||
for line in text.splitlines():
|
||||
if ':' not in line:
|
||||
continue
|
||||
key, _, val = line.partition(':')
|
||||
key = key.strip()
|
||||
val = val.strip()
|
||||
if key == 'Speed':
|
||||
m = re.match(r'(\d+)\s*Mb/s', val)
|
||||
if m:
|
||||
data['speed_mbps'] = int(m.group(1))
|
||||
elif 'Unknown' in val or 'unknown' in val:
|
||||
data['speed_mbps'] = None
|
||||
elif key == 'Duplex':
|
||||
data['duplex'] = val.lower()
|
||||
elif key == 'Port':
|
||||
data['port_type'] = val
|
||||
elif key == 'Auto-negotiation':
|
||||
data['auto_neg'] = (val.lower() == 'on')
|
||||
elif key == 'Link detected':
|
||||
data['link_detected'] = (val.lower() == 'yes')
|
||||
return data
|
||||
|
||||
@staticmethod
|
||||
def parse_ethtool_driver(text: str) -> dict:
|
||||
data: dict = {}
|
||||
for line in text.splitlines():
|
||||
if ':' not in line:
|
||||
continue
|
||||
key, _, val = line.partition(':')
|
||||
key = key.strip()
|
||||
val = val.strip()
|
||||
if key == 'driver':
|
||||
data['driver'] = val
|
||||
elif key == 'version':
|
||||
data['version'] = val
|
||||
elif key == 'firmware-version':
|
||||
data['firmware_version'] = val
|
||||
elif key == 'bus-info':
|
||||
data['bus_info'] = val
|
||||
return data
|
||||
|
||||
@staticmethod
|
||||
def parse_ethtool_pause(text: str) -> dict:
|
||||
data = {'rx_pause': False, 'tx_pause': False}
|
||||
for line in text.splitlines():
|
||||
if ':' not in line:
|
||||
continue
|
||||
key, _, val = line.partition(':')
|
||||
key = key.strip()
|
||||
val = val.strip().lower()
|
||||
if key == 'RX':
|
||||
data['rx_pause'] = (val == 'on')
|
||||
elif key == 'TX':
|
||||
data['tx_pause'] = (val == 'on')
|
||||
return data
|
||||
|
||||
@staticmethod
|
||||
def parse_ethtool_ring(text: str) -> dict:
|
||||
data: dict = {}
|
||||
in_current = False
|
||||
for line in text.splitlines():
|
||||
if 'Current hardware settings' in line:
|
||||
in_current = True
|
||||
continue
|
||||
if 'Pre-set maximums' in line:
|
||||
in_current = False
|
||||
continue
|
||||
if ':' not in line:
|
||||
continue
|
||||
key, _, val = line.partition(':')
|
||||
key = key.strip()
|
||||
val = val.strip()
|
||||
try:
|
||||
v = int(val)
|
||||
except ValueError:
|
||||
continue
|
||||
if in_current:
|
||||
if 'RX' in key and 'rx_current' not in data:
|
||||
data['rx_current'] = v
|
||||
elif 'TX' in key and 'tx_current' not in data:
|
||||
data['tx_current'] = v
|
||||
else:
|
||||
if 'RX' in key and 'rx_max' not in data:
|
||||
data['rx_max'] = v
|
||||
elif 'TX' in key and 'tx_max' not in data:
|
||||
data['tx_max'] = v
|
||||
return data
|
||||
|
||||
@staticmethod
|
||||
def parse_nic_stats(text: str) -> dict:
|
||||
"""Parse ethtool -S output into {key: int} dict."""
|
||||
data: dict = {}
|
||||
for line in text.splitlines():
|
||||
if ':' not in line:
|
||||
continue
|
||||
key, _, val = line.partition(':')
|
||||
key = key.strip()
|
||||
val = val.strip()
|
||||
try:
|
||||
data[key] = int(val)
|
||||
except ValueError:
|
||||
pass
|
||||
return data
|
||||
|
||||
@staticmethod
|
||||
def parse_ethtool_dom(text: str) -> dict:
|
||||
"""Parse ethtool -m (SFP DOM) output."""
|
||||
if not text:
|
||||
return {}
|
||||
lower = text.lower()
|
||||
if any(s in lower for s in ('cannot get', 'not supported', 'no sfp', 'operation not supported')):
|
||||
return {}
|
||||
|
||||
data: dict = {}
|
||||
for line in text.splitlines():
|
||||
if ':' not in line:
|
||||
continue
|
||||
key, _, val = line.partition(':')
|
||||
key = key.strip()
|
||||
val = val.strip()
|
||||
|
||||
if key == 'Vendor name':
|
||||
data['vendor'] = val
|
||||
elif key == 'Vendor PN':
|
||||
data['part_no'] = val
|
||||
elif key == 'Identifier':
|
||||
m = re.search(r'\((.+?)\)', val)
|
||||
if m:
|
||||
data['sfp_type'] = m.group(1)
|
||||
elif key == 'Connector':
|
||||
m = re.search(r'\((.+?)\)', val)
|
||||
if m:
|
||||
data['connector'] = m.group(1)
|
||||
elif key == 'Laser wavelength':
|
||||
m = re.match(r'(\d+)', val)
|
||||
if m:
|
||||
data['wavelength_nm'] = int(m.group(1))
|
||||
elif key == 'Laser bias current':
|
||||
m = re.match(r'([\d.]+)\s+mA', val)
|
||||
if m:
|
||||
data['bias_ma'] = float(m.group(1))
|
||||
elif key == 'Laser output power':
|
||||
m = re.search(r'/\s*([-\d.]+)\s*dBm', val)
|
||||
if m:
|
||||
try:
|
||||
data['tx_power_dbm'] = float(m.group(1))
|
||||
except ValueError:
|
||||
pass
|
||||
elif 'receiver' in key.lower() and ('power' in key.lower() or 'optical' in key.lower()):
|
||||
m = re.search(r'/\s*([-\d.]+)\s*dBm', val)
|
||||
if m:
|
||||
try:
|
||||
data['rx_power_dbm'] = float(m.group(1))
|
||||
except ValueError:
|
||||
pass
|
||||
elif key == 'Module temperature':
|
||||
m = re.match(r'([\d.]+)\s+degrees', val)
|
||||
if m:
|
||||
data['temp_c'] = float(m.group(1))
|
||||
elif key == 'Module voltage':
|
||||
m = re.match(r'([\d.]+)\s+V', val)
|
||||
if m:
|
||||
data['voltage_v'] = float(m.group(1))
|
||||
|
||||
return data
|
||||
|
||||
@staticmethod
|
||||
def parse_ip_link(text: str) -> dict:
|
||||
"""Parse ip -s link show output for basic link state and counters."""
|
||||
data: dict = {}
|
||||
lines = text.splitlines()
|
||||
for i, line in enumerate(lines):
|
||||
# MTU and state: "2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 ..."
|
||||
m = re.search(r'mtu\s+(\d+)', line)
|
||||
if m:
|
||||
data['mtu'] = int(m.group(1))
|
||||
m = re.search(r'state\s+(\S+)', line)
|
||||
if m:
|
||||
data['state'] = m.group(1).lower()
|
||||
# RX line follows "RX:" label
|
||||
if line.strip().startswith('RX:') and i + 1 < len(lines):
|
||||
vals = lines[i + 1].split()
|
||||
if len(vals) >= 5:
|
||||
try:
|
||||
data['ip_rx_bytes'] = int(vals[0])
|
||||
data['ip_rx_packets'] = int(vals[1])
|
||||
data['ip_rx_errors'] = int(vals[2])
|
||||
data['ip_rx_dropped'] = int(vals[3])
|
||||
except (ValueError, IndexError):
|
||||
pass
|
||||
if line.strip().startswith('TX:') and i + 1 < len(lines):
|
||||
vals = lines[i + 1].split()
|
||||
if len(vals) >= 5:
|
||||
try:
|
||||
data['ip_tx_bytes'] = int(vals[0])
|
||||
data['ip_tx_packets'] = int(vals[1])
|
||||
data['ip_tx_errors'] = int(vals[2])
|
||||
data['ip_tx_dropped'] = int(vals[3])
|
||||
except (ValueError, IndexError):
|
||||
pass
|
||||
return data
|
||||
|
||||
@staticmethod
|
||||
def parse_dmesg(text: str) -> List[dict]:
|
||||
"""Parse dmesg lines into [{timestamp, msg, severity}]."""
|
||||
events = []
|
||||
for line in text.splitlines():
|
||||
if not line.strip():
|
||||
continue
|
||||
# Extract timestamp from [ 123.456789]
|
||||
m = re.match(r'^\[\s*([\d.]+)\]\s*(.*)', line)
|
||||
if m:
|
||||
ts = m.group(1)
|
||||
msg = m.group(2)
|
||||
else:
|
||||
ts = ''
|
||||
msg = line
|
||||
|
||||
lower = msg.lower()
|
||||
if any(w in lower for w in ('error', 'fail', 'reset', 'panic', 'oops', 'hung', 'timeout')):
|
||||
severity = 'error'
|
||||
elif any(w in lower for w in ('warn', 'drop', 'lost', 'miss')):
|
||||
severity = 'warn'
|
||||
else:
|
||||
severity = 'info'
|
||||
|
||||
events.append({'timestamp': ts, 'msg': msg, 'severity': severity})
|
||||
return events
|
||||
|
||||
@staticmethod
|
||||
def parse_lldpctl(text: str) -> dict:
|
||||
"""Extract neighbor info from lldpctl output."""
|
||||
if not text or 'lldpd not running' in text or 'not found' in text.lower():
|
||||
return {'available': False}
|
||||
|
||||
data: dict = {'available': True}
|
||||
for line in text.splitlines():
|
||||
if ':' not in line:
|
||||
continue
|
||||
key, _, val = line.partition(':')
|
||||
key = key.strip()
|
||||
val = val.strip()
|
||||
if 'SysName' in key:
|
||||
data['neighbor_system'] = val
|
||||
elif 'PortID' in key and 'neighbor_port' not in data:
|
||||
data['neighbor_port'] = val
|
||||
elif 'ChassisID' in key and 'neighbor_chassis_id' not in data:
|
||||
data['neighbor_chassis_id'] = val
|
||||
return data
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Health analysis
|
||||
# ------------------------------------------------------------------
|
||||
@staticmethod
|
||||
def analyze(sections: dict, switch_port_data: dict) -> dict:
|
||||
"""Return {issues: [...], warnings: [...], info: [...]} health analysis."""
|
||||
issues: List[dict] = []
|
||||
warnings: List[dict] = []
|
||||
info: List[dict] = []
|
||||
|
||||
def add(collection, code, message):
|
||||
collection.append({'code': code, 'message': message})
|
||||
|
||||
carrier = sections.get('carrier', '?')
|
||||
eth = sections.get('ethtool', {})
|
||||
sysfs = sections.get('sysfs_stats', {})
|
||||
dom = sections.get('ethtool_dom', {})
|
||||
dmesg = sections.get('dmesg', [])
|
||||
lldp = sections.get('lldpctl', {})
|
||||
cc = sections.get('carrier_changes')
|
||||
|
||||
# Physical carrier
|
||||
if carrier == '0':
|
||||
add(issues, 'NO_CARRIER',
|
||||
'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')
|
||||
|
||||
# Duplex
|
||||
if eth.get('duplex') == 'half':
|
||||
add(issues, 'HALF_DUPLEX',
|
||||
'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
|
||||
srv_speed = eth.get('speed_mbps', 0) or 0
|
||||
if sw_speed > 0 and srv_speed > 0 and sw_speed != srv_speed:
|
||||
add(warnings, 'SPEED_MISMATCH',
|
||||
f'Speed mismatch: switch reports {sw_speed} Mbps, NIC reports {srv_speed} Mbps')
|
||||
|
||||
# SFP DOM power levels
|
||||
rx_dbm = dom.get('rx_power_dbm')
|
||||
tx_dbm = dom.get('tx_power_dbm')
|
||||
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')
|
||||
elif rx_dbm < -18:
|
||||
add(warnings, 'SFP_RX_LOW',
|
||||
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')
|
||||
|
||||
# Carrier changes (flapping)
|
||||
if cc is not None:
|
||||
if cc > 100:
|
||||
add(issues, 'CARRIER_FLAPPING',
|
||||
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')
|
||||
|
||||
# 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')
|
||||
elif crc > 10:
|
||||
add(warnings, 'CRC_ERRORS_LOW',
|
||||
f'CRC errors present ({crc}): cable or SFP quality issue')
|
||||
|
||||
# Kernel events
|
||||
err_events = [e for e in dmesg if e['severity'] == 'error']
|
||||
if err_events:
|
||||
add(warnings, 'KERNEL_EVENTS',
|
||||
f'{len(err_events)} recent kernel error event(s) for this interface in dmesg')
|
||||
|
||||
# LLDP validation: the neighbour the *server's* lldpd sees should be the switch
|
||||
# that this port belongs to. (The switch port's own LLDP entry describes the server,
|
||||
# so it must not be compared with the server's view of the switch.)
|
||||
if lldp.get('available'):
|
||||
expected_switch = (switch_port_data.get('switch_name') or '').lower()
|
||||
srv_neighbor = (lldp.get('neighbor_system') or '').lower()
|
||||
names_differ = expected_switch not in srv_neighbor and srv_neighbor not in expected_switch
|
||||
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?')
|
||||
else:
|
||||
add(info, 'LLDP_MISSING',
|
||||
'lldpd not running on server: install lldpd for full path validation')
|
||||
|
||||
return {'issues': issues, 'warnings': warnings, 'info': info}
|
||||
|
After Width: | Height: | Size: 88 KiB |
|
After Width: | Height: | Size: 164 KiB |
|
After Width: | Height: | Size: 674 KiB |
|
After Width: | Height: | Size: 67 KiB |
|
After Width: | Height: | Size: 145 KiB |
|
After Width: | Height: | Size: 162 KiB |
|
After Width: | Height: | Size: 108 KiB |
|
After Width: | Height: | Size: 214 KiB |
|
After Width: | Height: | Size: 161 KiB |
@@ -0,0 +1,22 @@
|
||||
[Unit]
|
||||
Description=Gandalf Network Monitor Daemon
|
||||
Documentation=https://gitea.lotusguild.org/LotusGuild/gandalf
|
||||
After=network.target
|
||||
Wants=network-online.target
|
||||
|
||||
[Service]
|
||||
Type=simple
|
||||
User=www-data
|
||||
WorkingDirectory=/var/www/html/prod
|
||||
ExecStart=/usr/bin/python3 /var/www/html/prod/monitor.py
|
||||
Restart=on-failure
|
||||
RestartSec=30
|
||||
TimeoutStopSec=10
|
||||
|
||||
# Logging
|
||||
StandardOutput=journal
|
||||
StandardError=journal
|
||||
SyslogIdentifier=gandalf-monitor
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
@@ -0,0 +1,56 @@
|
||||
"""Switch one Uptime Kuma maintenance window on and off (Kuma 2.x, over its Socket.IO API).
|
||||
|
||||
Kuma has no REST API for maintenance, so this logs in over the same socket its web UI
|
||||
uses. It only ever resumes or pauses the one window named in config, which is created
|
||||
once in Kuma ("manual" strategy, covering the monitors that a modem restart takes down):
|
||||
|
||||
"uptime_kuma": {"url": "http://10.10.10.25:3001", "username": "...", "password": "...",
|
||||
"maintenance_id": 7}
|
||||
|
||||
Nothing else in Kuma is read or changed.
|
||||
"""
|
||||
import logging
|
||||
from typing import Callable, Optional
|
||||
|
||||
import socketio
|
||||
|
||||
logger = logging.getLogger('gandalf.kuma')
|
||||
|
||||
|
||||
class KumaError(Exception):
|
||||
"""Kuma couldn't be reached, refused the login, or refused the change."""
|
||||
|
||||
|
||||
def configured(cfg: Optional[dict]) -> bool:
|
||||
cfg = cfg or {}
|
||||
return all(cfg.get(k) for k in ('url', 'username', 'password', 'maintenance_id'))
|
||||
|
||||
|
||||
def set_maintenance(cfg: dict, active: bool, client_factory: Optional[Callable] = None) -> None:
|
||||
"""Resume (active=True) or pause the configured maintenance window. Raises KumaError."""
|
||||
timeout = cfg.get('timeout', 10)
|
||||
factory = client_factory or (lambda: socketio.Client(
|
||||
reconnection=False, ssl_verify=cfg.get('verify_ssl', True)))
|
||||
sio = factory()
|
||||
try:
|
||||
sio.connect(cfg['url'], transports=['websocket'], wait_timeout=timeout)
|
||||
res = sio.call('login', {'username': cfg['username'], 'password': cfg['password'], 'token': ''},
|
||||
timeout=timeout) or {}
|
||||
if not res.get('ok'):
|
||||
if res.get('tokenRequired'):
|
||||
raise KumaError('the Kuma account has two-factor login, which Gandalf cannot answer')
|
||||
raise KumaError(f'login refused: {res.get("msg") or "no reason given"}')
|
||||
event = 'resumeMaintenance' if active else 'pauseMaintenance'
|
||||
res = sio.call(event, int(cfg['maintenance_id']), timeout=timeout) or {}
|
||||
if not res.get('ok'):
|
||||
raise KumaError(f'{event} refused: {res.get("msg") or "no reason given"}')
|
||||
logger.info(f'Uptime Kuma maintenance {cfg["maintenance_id"]} {"on" if active else "off"}')
|
||||
except KumaError:
|
||||
raise
|
||||
except Exception as e: # socketio raises its own errors and plain timeouts
|
||||
raise KumaError(f'{type(e).__name__}: {e}') from e
|
||||
finally:
|
||||
try:
|
||||
sio.disconnect()
|
||||
except Exception: # nosec B110 - nothing left to clean up
|
||||
pass
|
||||
@@ -0,0 +1,603 @@
|
||||
"""Client for AT&T BGW-series fiber gateways (tested on BGW320-505).
|
||||
|
||||
The gateway has no API, but its status pages are served without a login, so
|
||||
ModemClient scrapes them over HTTP with GET requests only: it cannot change
|
||||
anything on the gateway.
|
||||
|
||||
With an access code configured, ModemAdmin (at the end) also logs in to read the
|
||||
NAT session counts, the firewall log and speed test history, and to run the
|
||||
Troubleshoot page's ping from the gateway. None of that changes a setting. Its
|
||||
restart() is the one call that does something to the gateway, and it runs only
|
||||
when an admin presses Restart modem.
|
||||
|
||||
Units come from the gateway's own help text, checked against live readings:
|
||||
Rx/Tx power tenths of a dBm (-169 -> -16.9 dBm)
|
||||
Temperature degrees C
|
||||
Uptime D:HH:MM:SS on firmware 6.40 (older firmware sent plain seconds;
|
||||
both are accepted)
|
||||
|
||||
Deliberately not used, because the page disagrees with itself:
|
||||
Vcc / Tx Bias readings values do not match the documented scales, so only
|
||||
their alarm/warning flags are kept
|
||||
Rx LOS State reads 1 on a healthy link; "Optical WAN Operational
|
||||
Status" is the reliable signal
|
||||
Last Change does not count up, despite the help text
|
||||
"""
|
||||
import hashlib
|
||||
import html
|
||||
import logging
|
||||
import re
|
||||
import time
|
||||
from datetime import datetime, timezone
|
||||
from typing import Dict, List, Optional
|
||||
|
||||
import requests
|
||||
|
||||
logger = logging.getLogger('gandalf.modem')
|
||||
|
||||
_FIBER_PAGE = '/cgi-bin/fiberstat.ha'
|
||||
_BROADBAND_PAGE = '/cgi-bin/broadbandstatistics.ha'
|
||||
_SYSINFO_PAGE = '/cgi-bin/sysinfo.ha'
|
||||
|
||||
_ROW_RE = re.compile(r'<th\b[^>]*>(.*?)</th>\s*<td\b[^>]*>(.*?)</td>', re.I | re.S)
|
||||
_TAG_RE = re.compile(r'<[^>]+>')
|
||||
# e.g. "0 (Threshold -292)": alarm flag, then the limit
|
||||
_DOM_CELL_RE = re.compile(r'<td\b[^>]*>\s*(\d+)\s*\(Threshold\s+(-?\d+)\)\s*</td>', re.I)
|
||||
|
||||
# Page heading -> (result key, scale to real units; None = reading is unusable)
|
||||
_DOM_METRICS = {
|
||||
'Temperature': ('temperature', 1.0),
|
||||
'Vcc': ('vcc', None),
|
||||
'Tx Bias': ('tx_bias', None),
|
||||
'Tx Power': ('tx_power', 0.1),
|
||||
'Rx Power': ('rx_power', 0.1),
|
||||
}
|
||||
|
||||
_COUNTERS = {
|
||||
'rx_bytes': 'Receive Bytes',
|
||||
'tx_bytes': 'Transmit Bytes',
|
||||
'rx_errors': 'Receive Errors',
|
||||
'tx_errors': 'Transmit Errors',
|
||||
'rx_drops': 'Receive Drops',
|
||||
'tx_drops': 'Transmit Drops',
|
||||
}
|
||||
|
||||
|
||||
class ModemUnreachable(Exception):
|
||||
"""The gateway did not answer (power, cabling, or routing problem)."""
|
||||
|
||||
|
||||
class ModemDataInvalid(Exception):
|
||||
"""The gateway answered but the page was not what we can parse.
|
||||
|
||||
AT&T pushes firmware automatically, so this is how a layout change or a
|
||||
newly login-protected page shows up.
|
||||
"""
|
||||
|
||||
|
||||
def parse_rows(page: str) -> Dict[str, str]:
|
||||
"""Return {label: value} for the page's <th>/<td> rows; the first label wins.
|
||||
|
||||
First wins because labels repeat: "Transmit Packets" appears under both
|
||||
IPv4 and IPv6, and the IPv4 block comes first.
|
||||
"""
|
||||
rows: Dict[str, str] = {}
|
||||
for label, value in _ROW_RE.findall(page):
|
||||
key = html.unescape(_TAG_RE.sub('', label)).strip()
|
||||
if key:
|
||||
rows.setdefault(key, ' '.join(html.unescape(_TAG_RE.sub('', value)).split()))
|
||||
return rows
|
||||
|
||||
|
||||
def parse_dom_metrics(page: str) -> Dict[str, dict]:
|
||||
"""Parse the fiber page's Temperature / Vcc / Tx Bias / Tx Power / Rx Power tables."""
|
||||
metrics: Dict[str, dict] = {}
|
||||
for heading, (key, scale) in _DOM_METRICS.items():
|
||||
m = re.search(
|
||||
rf'<h1>\s*{re.escape(heading)}(?: |\s)+Currently\s+(-?\d+)\s*</h1>(.*?)</table>',
|
||||
page, re.I | re.S,
|
||||
)
|
||||
if not m:
|
||||
continue
|
||||
cells = _DOM_CELL_RE.findall(m.group(2))
|
||||
if len(cells) != 4: # alarm low, alarm high, warning low, warning high
|
||||
continue
|
||||
|
||||
def limit(raw: str, scale: Optional[float] = scale) -> Optional[float]:
|
||||
return round(int(raw) * scale, 1) if scale is not None else None
|
||||
|
||||
metrics[key] = {
|
||||
'value': limit(m.group(1)),
|
||||
'alarm_low': limit(cells[0][1]),
|
||||
'alarm_high': limit(cells[1][1]),
|
||||
'warn_low': limit(cells[2][1]),
|
||||
'warn_high': limit(cells[3][1]),
|
||||
'alarm_flag': cells[0][0] != '0' or cells[1][0] != '0',
|
||||
'warn_flag': cells[2][0] != '0' or cells[3][0] != '0',
|
||||
}
|
||||
return metrics
|
||||
|
||||
|
||||
def metric_status(metric: dict) -> str:
|
||||
"""Classify a DOM metric as 'alarm', 'warning', or 'ok'.
|
||||
|
||||
Trusts the module's own flags, and also compares the reading to its limits
|
||||
in case the flags are latched off.
|
||||
"""
|
||||
value = metric.get('value')
|
||||
|
||||
def outside(low: Optional[float], high: Optional[float]) -> bool:
|
||||
if value is None:
|
||||
return False
|
||||
return (low is not None and value <= low) or (high is not None and value >= high)
|
||||
|
||||
if metric.get('alarm_flag') or outside(metric.get('alarm_low'), metric.get('alarm_high')):
|
||||
return 'alarm'
|
||||
if metric.get('warn_flag') or outside(metric.get('warn_low'), metric.get('warn_high')):
|
||||
return 'warning'
|
||||
return 'ok'
|
||||
|
||||
|
||||
def _to_int(raw: Optional[str]) -> Optional[int]:
|
||||
try:
|
||||
return int(raw) # type: ignore[arg-type]
|
||||
except (TypeError, ValueError):
|
||||
return None
|
||||
|
||||
|
||||
def parse_uptime(raw: Optional[str]) -> Optional[int]:
|
||||
"""Seconds since the gateway restarted, from 'D:HH:MM:SS' (e.g. 03:06:29:34) or plain seconds."""
|
||||
raw = (raw or '').strip()
|
||||
if re.fullmatch(r'\d+', raw):
|
||||
return int(raw)
|
||||
m = re.fullmatch(r'(\d+):(\d{1,2}):(\d{1,2}):(\d{1,2})', raw)
|
||||
if not m:
|
||||
return None
|
||||
d, h, mi, sec = (int(x) for x in m.groups())
|
||||
return ((d * 24 + h) * 60 + mi) * 60 + sec
|
||||
|
||||
|
||||
def wan_problems(data: dict) -> List[str]:
|
||||
"""Return human-readable reasons the WAN is down; empty when it looks healthy."""
|
||||
problems = []
|
||||
if (data.get('broadband_state') or '').lower() != 'up':
|
||||
problems.append(f'broadband connection is {data.get("broadband_state") or "unknown"}')
|
||||
if (data.get('optical_state') or '').lower() != 'up':
|
||||
problems.append(f'optical WAN is {data.get("optical_state") or "unknown"}')
|
||||
pon = data.get('pon_state')
|
||||
if pon and 'O5' not in pon: # O5 is the PON "operation" state; older firmware may omit the field
|
||||
problems.append(f'PON link state is {pon}')
|
||||
return problems
|
||||
|
||||
|
||||
def build_status(fiber_page: str, broadband_page: str, sysinfo_page: str = '') -> dict:
|
||||
"""Combine the status pages into one dict. Raises ModemDataInvalid if unusable."""
|
||||
fiber = parse_rows(fiber_page)
|
||||
broadband = parse_rows(broadband_page)
|
||||
sysinfo = parse_rows(sysinfo_page)
|
||||
|
||||
if 'Optical WAN Operational Status' not in fiber:
|
||||
raise ModemDataInvalid('fiber page is missing "Optical WAN Operational Status"')
|
||||
if 'Broadband Connection' not in broadband:
|
||||
raise ModemDataInvalid('broadband page is missing "Broadband Connection"')
|
||||
|
||||
metrics = parse_dom_metrics(fiber_page)
|
||||
data = {
|
||||
'model': sysinfo.get('Model Number', ''),
|
||||
'firmware': sysinfo.get('Software Version', ''),
|
||||
'uptime_s': parse_uptime(sysinfo.get('Time Since Last Reboot')),
|
||||
'broadband_state': broadband.get('Broadband Connection', ''),
|
||||
'source': broadband.get('Broadband Connection Source', ''),
|
||||
'wan_ip': broadband.get('Broadband IPv4 Address', ''),
|
||||
'pon_state': broadband.get('PON Link Status', ''),
|
||||
'uni_state': broadband.get('UNI Status', ''),
|
||||
'line_speed_mbps': _to_int(broadband.get('Current Speed (Mbps)')),
|
||||
'optical_state': fiber.get('Optical WAN Operational Status', ''),
|
||||
'wavelength': fiber.get('Wave Length', ''),
|
||||
'optics_part_no': fiber.get('Vendor PN', ''),
|
||||
'optics': metrics,
|
||||
'counters': {k: _to_int(broadband.get(label)) for k, label in _COUNTERS.items()},
|
||||
}
|
||||
|
||||
# With a healthy link the optics must be readable; if not, the layout changed.
|
||||
# With a cut fiber they may legitimately be blank, so don't report that as invalid.
|
||||
if not wan_problems(data) and 'rx_power' not in metrics:
|
||||
raise ModemDataInvalid('link is up but no Rx power reading was found')
|
||||
return data
|
||||
|
||||
|
||||
def counter_rates(current: dict, previous: Optional[dict], elapsed_s: float) -> Dict[str, Optional[float]]:
|
||||
"""Return per-second rates between counter snapshots.
|
||||
|
||||
A rate is None rather than a bogus value on the first poll, or when a counter
|
||||
goes backwards because the gateway rebooted.
|
||||
"""
|
||||
rates: Dict[str, Optional[float]] = {}
|
||||
for key, now_val in current.items():
|
||||
then = (previous or {}).get(key)
|
||||
if now_val is None or then is None or elapsed_s <= 0 or now_val < then:
|
||||
rates[key] = None
|
||||
else:
|
||||
rates[key] = (now_val - then) / elapsed_s
|
||||
return rates
|
||||
|
||||
|
||||
class ModemClient:
|
||||
def __init__(self, cfg: dict):
|
||||
self.base_url = cfg['url'].rstrip('/')
|
||||
self.timeout = cfg.get('timeout', 10)
|
||||
self.session = requests.Session()
|
||||
|
||||
def _get(self, path: str) -> str:
|
||||
try:
|
||||
# Protected pages redirect or render a login form, so never follow redirects.
|
||||
resp = self.session.get(f'{self.base_url}{path}', timeout=self.timeout, allow_redirects=False)
|
||||
except requests.RequestException as e:
|
||||
raise ModemUnreachable(f'{path}: {e}') from e
|
||||
if resp.status_code != 200:
|
||||
raise ModemDataInvalid(f'{path} returned HTTP {resp.status_code}')
|
||||
if re.search(r'<title>\s*Login', resp.text, re.I):
|
||||
raise ModemDataInvalid(f'{path} now requires a login')
|
||||
return resp.text
|
||||
|
||||
def poll(self) -> dict:
|
||||
"""Return gateway status. Raises ModemUnreachable or ModemDataInvalid."""
|
||||
fiber = self._get(_FIBER_PAGE)
|
||||
broadband = self._get(_BROADBAND_PAGE)
|
||||
try:
|
||||
sysinfo = self._get(_SYSINFO_PAGE)
|
||||
except (ModemUnreachable, ModemDataInvalid) as e:
|
||||
# Model and uptime are nice to have, not worth failing the poll over.
|
||||
logger.warning(f'Modem system info unavailable: {e}')
|
||||
sysinfo = ''
|
||||
data = build_status(fiber, broadband, sysinfo)
|
||||
data['updated'] = datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S UTC')
|
||||
return data
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# WAN history: outages and gateway restarts, which are too brief to catch by polling
|
||||
# ---------------------------------------------------------------------------
|
||||
LOG_WAN_FAILED = 'NETWORK_WAN_FAILED_2'
|
||||
LOG_WAN_RESTORED = 'NETWORK_WAN_RESTORED_2'
|
||||
LOG_WAN_UNSTABLE = 'NETWORK_WAN_FAILED_MULTIPLE_TIMES_2'
|
||||
LOG_MODEM_RESTARTED = 'SMART_POWER_MODEM_RESTARTED'
|
||||
WAN_LOG_KEYS = (LOG_WAN_FAILED, LOG_WAN_RESTORED, LOG_WAN_UNSTABLE, LOG_MODEM_RESTARTED)
|
||||
# An app or firmware update finishing. The UDM often drops its WAN while the Network app
|
||||
# updates, and Smart Power may then power-cycle a modem that was fine.
|
||||
LOG_NETWORK_UPDATED = 'NETWORK_UPDATED'
|
||||
LOG_FIRMWARE_UPDATED = 'FIRMWARE_UPDATED_V2'
|
||||
_UPDATE_KEY_RE = re.compile(r'[A-Z_]+_(?:UPDATED|UPGRADED)(?:_V\d+)?')
|
||||
|
||||
|
||||
def is_update_key(key: str) -> bool:
|
||||
"""True for log keys that mean an update finished (other app names follow the same pattern)."""
|
||||
return key in (LOG_NETWORK_UPDATED, LOG_FIRMWARE_UPDATED) or (
|
||||
bool(_UPDATE_KEY_RE.fullmatch(key or '')) and 'AVAILABLE' not in key
|
||||
and not key.startswith('MADE_CHANGES'))
|
||||
|
||||
|
||||
def wanted_log_key(key: str) -> bool:
|
||||
return key in WAN_LOG_KEYS or is_update_key(key)
|
||||
|
||||
|
||||
def update_label(event: dict) -> str:
|
||||
"""'UniFi Network 11.0.97 to 11.0.99' from an update log event."""
|
||||
what = event.get('app') or event.get('device') or 'UniFi'
|
||||
before, after = event.get('previous') or '', event.get('version') or ''
|
||||
if before and after:
|
||||
return f'{what} {before} to {after}'
|
||||
return f'{what} {after}'.strip()
|
||||
|
||||
_HISTORY_LIMIT = 50
|
||||
# The RPDU's log entry and the gateway's calculated boot time can differ by this much.
|
||||
_RESTART_MATCH_WINDOW_S = 600
|
||||
|
||||
|
||||
def apply_wan_events(history: dict, events: List[dict]) -> List[dict]:
|
||||
"""Fold UniFi log events into *history* in place and return the ones worth a ticket.
|
||||
|
||||
Each event is {'key', 'ts' (epoch seconds), 'device', 'wan'}.
|
||||
"""
|
||||
outages = history.setdefault('outages', [])
|
||||
restarts = history.setdefault('restarts', [])
|
||||
actionable = []
|
||||
for e in sorted(events, key=lambda ev: ev['ts']):
|
||||
key = e['key']
|
||||
if key == LOG_WAN_FAILED:
|
||||
if not any(o.get('restored_at') is None for o in outages):
|
||||
outages.append({'failed_at': e['ts'], 'restored_at': None, 'wan': e.get('wan', '')})
|
||||
elif key == LOG_WAN_RESTORED:
|
||||
for o in reversed(outages):
|
||||
if o.get('restored_at') is None:
|
||||
o['restored_at'] = e['ts']
|
||||
break
|
||||
elif key == LOG_MODEM_RESTARTED:
|
||||
restarts.append({'at': e['ts'], 'by': e.get('device') or 'smart power', 'confirmed': False})
|
||||
actionable.append(e)
|
||||
elif key == LOG_WAN_UNSTABLE:
|
||||
actionable.append(e)
|
||||
del outages[:-_HISTORY_LIMIT]
|
||||
del restarts[:-_HISTORY_LIMIT]
|
||||
return actionable
|
||||
|
||||
|
||||
def record_uptime_reset(history: dict, boot_ts: float) -> None:
|
||||
"""Note that the gateway's uptime went backwards, attributing it to a logged restart if possible."""
|
||||
restarts = history.setdefault('restarts', [])
|
||||
for r in reversed(restarts):
|
||||
if abs(r['at'] - boot_ts) <= _RESTART_MATCH_WINDOW_S:
|
||||
r['confirmed'] = True
|
||||
return
|
||||
restarts.append({'at': boot_ts, 'by': None, 'confirmed': True})
|
||||
del restarts[:-_HISTORY_LIMIT]
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# WAN quality: UniFi's own 5 minute health timeline (high latency, packet loss, down),
|
||||
# the same data its Network app charts. Read only; Gandalf doesn't measure it again.
|
||||
# ---------------------------------------------------------------------------
|
||||
QUALITY_STATES = ('ok', 'latency', 'loss', 'down') # mildest to worst
|
||||
QUALITY_PERIOD_S = 300
|
||||
|
||||
|
||||
def wan_quality(dashboard: dict, now: float) -> Optional[dict]:
|
||||
"""The primary WAN's health timeline from UniFi's aggregated dashboard, or None.
|
||||
|
||||
Returns {'wan', 'periods': [{'ts', 'state'}], 'downtime': [{'ts', 'seconds'}],
|
||||
'latencies': {service: ms}, 'updated'}. Each period is 5 minutes; its state is the
|
||||
worst flag UniFi set for it.
|
||||
"""
|
||||
details = ((dashboard or {}).get('wan_history') or {}).get('wan_history_details') or []
|
||||
if not details:
|
||||
return None
|
||||
primary = next((d for d in details if d.get('network_group') == 'WAN'), details[0])
|
||||
periods = []
|
||||
for h in primary.get('health_history') or []:
|
||||
if not isinstance(h.get('timestamp'), (int, float)):
|
||||
continue
|
||||
state = ('down' if h.get('wan_downtime') else 'loss' if h.get('packet_loss')
|
||||
else 'latency' if h.get('high_latency') else 'ok')
|
||||
periods.append({'ts': h['timestamp'] / 1000, 'state': state})
|
||||
periods.sort(key=lambda p: p['ts'])
|
||||
downtime = sorted(
|
||||
({'ts': d['timestamp'] / 1000, 'seconds': d.get('downtime_in_seconds') or 0}
|
||||
for d in primary.get('downtime_history') or [] if isinstance(d.get('timestamp'), (int, float))),
|
||||
key=lambda d: d['ts'])
|
||||
latencies = {}
|
||||
for w in ((dashboard.get('wan') or {}).get('wan_details') or []):
|
||||
if w.get('network_group') == primary.get('network_group'):
|
||||
for s in (w.get('stats') or {}).get('service_latencies') or []:
|
||||
if s.get('service_name') and isinstance(s.get('latency'), (int, float)):
|
||||
latencies[s['service_name']] = s['latency']
|
||||
return {'wan': primary.get('network_group') or '', 'periods': periods, 'downtime': downtime,
|
||||
'latencies': latencies, 'updated': now}
|
||||
|
||||
|
||||
def quality_counts(periods: List[dict], since: float) -> Dict[str, int]:
|
||||
"""How many periods starting at or after *since* were in each state."""
|
||||
counts = {s: 0 for s in QUALITY_STATES}
|
||||
for p in periods:
|
||||
if p['ts'] >= since and p['state'] in counts:
|
||||
counts[p['state']] += 1
|
||||
return counts
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Logged-in checks, used only when an access code is configured. Two pages are
|
||||
# read: the NAT table's session counts, and the Troubleshoot page's ping test,
|
||||
# which runs a ping from the gateway itself. Neither changes any setting.
|
||||
# ---------------------------------------------------------------------------
|
||||
_LOGIN_PAGE = '/cgi-bin/login.ha'
|
||||
_NAT_PAGE = '/cgi-bin/nattable.ha'
|
||||
_DIAG_PAGE = '/cgi-bin/diag.ha'
|
||||
_LOGS_PAGE = '/cgi-bin/logs.ha'
|
||||
_SPEED_PAGE = '/cgi-bin/speed.ha'
|
||||
_RESTART_PAGE = '/cgi-bin/restart.ha'
|
||||
_RESTARTING_PAGE = '/cgi-bin/restarting.ha'
|
||||
# Firewall log row: number, ISO time (gateway's local clock), source, destination, protocol, reason
|
||||
_FW_ROW_RE = re.compile(r'<tr[^>]*>\s*<td[^>]*>\s*\d+\s*</td>\s*<td>\s*([^<]+?)\s*</td>\s*<td>\s*([^<]*?)\s*</td>'
|
||||
r'\s*<td>\s*([^<]*?)\s*</td>\s*<td>\s*([^<]*?)\s*</td>\s*<td>\s*([^<]*?)\s*</td>\s*</tr>', re.I)
|
||||
_CELL_RE = re.compile(r'<td\b[^>]*>(.*?)</td>', re.I | re.S)
|
||||
_NONCE_RE = re.compile(r'name="nonce"\s+value="([0-9a-f]+)"', re.I)
|
||||
_PROGRESS_RE = re.compile(r'<textarea[^>]*name="ProgressWindow"[^>]*>(.*?)</textarea>', re.I | re.S)
|
||||
_PING_STATS_RE = re.compile(r'(\d+) packets transmitted, (\d+) (?:packets )?received')
|
||||
_PING_RTT_RE = re.compile(r'min/avg/max\S* = ([\d.]+)/([\d.]+)/([\d.]+)')
|
||||
# After a failed login, leave the gateway alone for this long (it may lock the account)
|
||||
LOGIN_BACKOFF_S = 1800
|
||||
|
||||
|
||||
class ModemLoginFailed(Exception):
|
||||
"""The access code was refused, or the login page wasn't what we expect."""
|
||||
|
||||
|
||||
def login_hash(code: str, nonce: str) -> str:
|
||||
"""What the login page's script posts: md5 of the access code followed by the nonce."""
|
||||
# The gateway's login protocol dictates md5; it isn't used to protect anything here
|
||||
return hashlib.md5((code + nonce).encode(), usedforsecurity=False).hexdigest() # nosec B303 B324
|
||||
|
||||
|
||||
def is_login_page(page: str) -> bool:
|
||||
return 'Access Code Required' in page or bool(re.search(r'<title>\s*Login', page, re.I))
|
||||
|
||||
|
||||
def parse_nat_summary(page: str) -> Optional[Dict[str, int]]:
|
||||
"""{'in_use', 'available'} from the NAT table page, or None if the counts are missing."""
|
||||
rows = {_TAG_RE.sub('', k).strip(): _TAG_RE.sub('', v).strip() for k, v in _ROW_RE.findall(page)}
|
||||
try:
|
||||
return {'in_use': int(rows['Total sessions in use']),
|
||||
'available': int(rows['Total sessions available'])}
|
||||
except (KeyError, ValueError):
|
||||
return None
|
||||
|
||||
|
||||
def parse_ping_output(text: str) -> Optional[dict]:
|
||||
"""{'sent', 'received', 'loss_pct', 'min_ms', 'avg_ms', 'max_ms'} from busybox ping output,
|
||||
or None until the test has finished. Times are None when every packet was lost."""
|
||||
stats = _PING_STATS_RE.search(text or '')
|
||||
if not stats:
|
||||
return None
|
||||
sent, received = int(stats.group(1)), int(stats.group(2))
|
||||
rtt = _PING_RTT_RE.search(text)
|
||||
lo, avg, hi = (float(x) for x in rtt.groups()) if rtt else (None, None, None)
|
||||
return {'sent': sent, 'received': received,
|
||||
'loss_pct': round(100 * (sent - received) / sent) if sent else 100,
|
||||
'min_ms': lo, 'avg_ms': avg, 'max_ms': hi}
|
||||
|
||||
|
||||
def parse_firewall_log(page: str) -> List[dict]:
|
||||
"""Rows of the gateway's firewall log (Logs page): {'ts', 'src', 'dst', 'proto', 'reason'}.
|
||||
'ts' is the gateway's local time as ISO text, so rows sort by it."""
|
||||
rows = [dict(zip(('ts', 'src', 'dst', 'proto', 'reason'), m.groups())) for m in _FW_ROW_RE.finditer(page)]
|
||||
return sorted((r for r in rows if re.match(r'\d{4}-\d\d-\d\dT', r['ts'])), key=lambda r: r['ts'])
|
||||
|
||||
|
||||
def firewall_kind(reason: str) -> str:
|
||||
"""'flood' (new connections over the gateway's fixed rate limit), 'invalid', or 'other'."""
|
||||
reason = reason.lower()
|
||||
return 'flood' if 'flood' in reason else 'invalid' if 'invalid' in reason else 'other'
|
||||
|
||||
|
||||
def parse_speed_tests(page: str) -> List[dict]:
|
||||
"""The gateway's own speed test history, newest first:
|
||||
{'at' (as the page shows it), 'direction', 'mbps', 'latency_ms', 'ok'}."""
|
||||
i = page.find('Test History')
|
||||
out = []
|
||||
for row in re.findall(r'<tr\b[^>]*>(.*?)</tr>', page[i:] if i >= 0 else '', re.I | re.S):
|
||||
cells = [_TAG_RE.sub('', c).strip() for c in _CELL_RE.findall(row)]
|
||||
if len(cells) < 6 or cells[1] not in ('upstream', 'downstream'):
|
||||
continue
|
||||
try:
|
||||
out.append({'at': cells[0], 'direction': cells[1], 'mbps': round(float(cells[2]), 1),
|
||||
'latency_ms': round(float(cells[4]), 1), 'ok': cells[5].lower() == 'success'})
|
||||
except ValueError:
|
||||
continue
|
||||
return out
|
||||
|
||||
|
||||
class ModemAdmin:
|
||||
"""Logged-in session on the gateway, kept between checks and renewed when it expires.
|
||||
|
||||
Logs in at most once per call, and not at all for LOGIN_BACKOFF_S after a refusal.
|
||||
Raises ModemUnreachable, ModemDataInvalid or ModemLoginFailed.
|
||||
"""
|
||||
|
||||
def __init__(self, cfg: dict, clock=None, sleep=None):
|
||||
self.base_url = cfg['url'].rstrip('/')
|
||||
self._code = cfg['access_code']
|
||||
self.timeout = cfg.get('timeout', 10)
|
||||
self.session = requests.Session()
|
||||
self._clock = clock or time.time
|
||||
self._sleep = sleep or time.sleep
|
||||
self.login_failed_at: Optional[float] = None
|
||||
|
||||
def _request(self, method: str, path: str, timeout: Optional[float] = None, **kw) -> requests.Response:
|
||||
try:
|
||||
return self.session.request(method, f'{self.base_url}{path}', allow_redirects=False,
|
||||
timeout=timeout or self.timeout, **kw)
|
||||
except requests.RequestException as e:
|
||||
raise ModemUnreachable(f'{path}: {e}') from e
|
||||
|
||||
def _login(self) -> None:
|
||||
if self.login_failed_at and self._clock() - self.login_failed_at < LOGIN_BACKOFF_S:
|
||||
raise ModemLoginFailed('waiting after a refused login')
|
||||
page = self._request('GET', _LOGIN_PAGE).text
|
||||
nonce = _NONCE_RE.search(page)
|
||||
if not nonce: # the first visit only sets the session cookie
|
||||
nonce = _NONCE_RE.search(self._request('GET', _LOGIN_PAGE).text)
|
||||
if not nonce:
|
||||
raise ModemDataInvalid('login page has no nonce')
|
||||
resp = self._request('POST', _LOGIN_PAGE, data={
|
||||
'nonce': nonce.group(1), 'password': '*' * len(self._code), 'Continue': 'Continue',
|
||||
'hashpassword': login_hash(self._code, nonce.group(1)),
|
||||
})
|
||||
if resp.status_code != 302 or is_login_page(resp.text):
|
||||
self.login_failed_at = self._clock()
|
||||
raise ModemLoginFailed('the gateway refused the access code')
|
||||
self.login_failed_at = None
|
||||
|
||||
def _page(self, path: str, timeout: Optional[float] = None) -> str:
|
||||
"""A protected page, logging in first if the session has expired."""
|
||||
resp = self._request('GET', path, timeout)
|
||||
if resp.status_code != 200 or is_login_page(resp.text):
|
||||
self._login()
|
||||
resp = self._request('GET', path, timeout)
|
||||
if resp.status_code != 200 or is_login_page(resp.text):
|
||||
raise ModemDataInvalid(f'{path} returned HTTP {resp.status_code} after logging in')
|
||||
return resp.text
|
||||
|
||||
def nat_sessions(self) -> Dict[str, int]:
|
||||
# The page lists every session too, so it can be large (hundreds of KB)
|
||||
counts = parse_nat_summary(self._page(_NAT_PAGE, timeout=max(self.timeout, 30)))
|
||||
if counts is None:
|
||||
raise ModemDataInvalid('NAT table page has no session counts')
|
||||
return counts
|
||||
|
||||
def firewall_log(self) -> List[dict]:
|
||||
return parse_firewall_log(self._page(_LOGS_PAGE))
|
||||
|
||||
def speed_tests(self) -> List[dict]:
|
||||
return parse_speed_tests(self._page(_SPEED_PAGE))
|
||||
|
||||
def restart(self) -> str:
|
||||
"""Restart the gateway from its Restart Device page: the one change this client makes,
|
||||
and only when an admin asks.
|
||||
|
||||
Two steps, as in a browser: posting the form only answers with a redirect to
|
||||
restarting.ha, and loading that page is what starts the restart (firmware 6.40; a
|
||||
post alone leaves the gateway running). Returns 'accepted' once that page says it is
|
||||
restarting, or 'unconfirmed' when the gateway dropped the connection first.
|
||||
"""
|
||||
nonce = _NONCE_RE.search(self._page(_RESTART_PAGE))
|
||||
if not nonce:
|
||||
raise ModemDataInvalid('Restart page has no nonce')
|
||||
timeout = max(self.timeout, 30)
|
||||
try:
|
||||
resp = self.session.post(f'{self.base_url}{_RESTART_PAGE}', allow_redirects=False,
|
||||
timeout=timeout, data={'nonce': nonce.group(1), 'Restart': 'Restart'})
|
||||
if resp.status_code == 302 and _RESTARTING_PAGE in (resp.headers.get('Location') or ''):
|
||||
resp = self.session.get(f'{self.base_url}{_RESTARTING_PAGE}', allow_redirects=False,
|
||||
timeout=timeout)
|
||||
except (requests.ConnectionError, requests.Timeout):
|
||||
return 'unconfirmed'
|
||||
if resp.status_code != 200 or is_login_page(resp.text) or 'restarting' not in resp.text.lower():
|
||||
raise ModemDataInvalid(f'Restart was not started (HTTP {resp.status_code})')
|
||||
return 'accepted'
|
||||
|
||||
def ping(self, target: str, wait_s: float = 30) -> dict:
|
||||
"""Ping *target* from the gateway (its Troubleshoot page; 5 packets) and return the result."""
|
||||
nonce = _NONCE_RE.search(self._page(_DIAG_PAGE))
|
||||
if not nonce:
|
||||
raise ModemDataInvalid('Troubleshoot page has no nonce')
|
||||
resp = self._request('POST', _DIAG_PAGE, timeout=max(self.timeout, 30), data={
|
||||
'nonce': nonce.group(1), 'WebAddress': target, 'protopref': 'IPv4', 'Ping': 'Ping'})
|
||||
deadline = self._clock() + wait_s
|
||||
page = resp.text
|
||||
while True:
|
||||
window = _PROGRESS_RE.search(page)
|
||||
result = parse_ping_output(html.unescape(window.group(1)) if window else '')
|
||||
if result is not None:
|
||||
return dict(result, target=target)
|
||||
if self._clock() >= deadline:
|
||||
raise ModemDataInvalid(f'ping to {target} from the gateway did not finish')
|
||||
self._sleep(3)
|
||||
page = self._page(_DIAG_PAGE)
|
||||
|
||||
|
||||
SLOW_MS = 150 # a ping slower than this, on a link that normally answers in ~15 ms, is "slow"
|
||||
|
||||
|
||||
def ping_verdict(gateway: dict, ours_ms: Optional[float]) -> str:
|
||||
"""Where the delay is, from the gateway's own ping and ours through it at the same time.
|
||||
|
||||
'upstream': the gateway's ping is slow or lossy too, so it's past the gateway (the ISP).
|
||||
'gateway': the gateway's ping is fine but ours through it is slow, so the delay is in
|
||||
the gateway or between it and the router.
|
||||
'clear': both fine; the slow spell had passed by the time of the test.
|
||||
"""
|
||||
avg = gateway.get('avg_ms')
|
||||
if avg is None or avg >= SLOW_MS or (gateway.get('loss_pct') or 0) >= 20:
|
||||
return 'upstream'
|
||||
if ours_ms is not None and ours_ms >= SLOW_MS:
|
||||
return 'gateway'
|
||||
return 'clear'
|
||||
@@ -0,0 +1,5 @@
|
||||
{
|
||||
"devDependencies": {
|
||||
"eslint": "^8.57.1"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
flask>=2.2.0
|
||||
gunicorn>=20.1.0
|
||||
ldap3>=2.9
|
||||
pymysql>=1.1.0
|
||||
requests>=2.31.0
|
||||
urllib3>=2.0.0
|
||||
python-socketio[client]>=5.8
|
||||
@@ -0,0 +1,126 @@
|
||||
-- Gandalf Network Monitor: Database Schema
|
||||
-- Run on MariaDB LXC 149 (10.10.10.50)
|
||||
|
||||
CREATE DATABASE IF NOT EXISTS gandalf
|
||||
CHARACTER SET utf8mb4
|
||||
COLLATE utf8mb4_unicode_ci;
|
||||
|
||||
USE gandalf;
|
||||
|
||||
-- ── Network events (open and resolved alerts) ─────────────────────────
|
||||
CREATE TABLE IF NOT EXISTS network_events (
|
||||
id INT AUTO_INCREMENT PRIMARY KEY,
|
||||
event_type VARCHAR(60) NOT NULL,
|
||||
severity ENUM('critical','warning','info') NOT NULL DEFAULT 'warning',
|
||||
source_type VARCHAR(20) NOT NULL, -- 'prometheus', 'unifi', 'ping'
|
||||
target_name VARCHAR(255) NOT NULL, -- hostname or device name
|
||||
target_detail VARCHAR(255) NOT NULL DEFAULT '', -- interface name, device type, IP
|
||||
description TEXT,
|
||||
first_seen TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
||||
last_seen TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
|
||||
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_target (target_name, target_detail),
|
||||
INDEX idx_type (event_type),
|
||||
-- Compound index for hot upsert_event lookup: event_type+target+resolved_at
|
||||
INDEX idx_event_lookup (event_type, target_name, target_detail, resolved_at)
|
||||
) ENGINE=InnoDB;
|
||||
|
||||
-- ── Suppression rules ─────────────────────────────────────────────────
|
||||
CREATE TABLE IF NOT EXISTS suppression_rules (
|
||||
id INT AUTO_INCREMENT PRIMARY KEY,
|
||||
target_type VARCHAR(50) NOT NULL, -- 'host', 'interface', 'unifi_device', 'all'
|
||||
target_name VARCHAR(255) NOT NULL DEFAULT '',
|
||||
target_detail VARCHAR(255) NOT NULL DEFAULT '',
|
||||
reason TEXT NOT NULL,
|
||||
suppressed_by VARCHAR(255) NOT NULL,
|
||||
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
||||
expires_at TIMESTAMP NULL, -- NULL = manual (never auto-expires)
|
||||
active BOOLEAN NOT NULL DEFAULT TRUE,
|
||||
|
||||
INDEX idx_active_exp (active, expires_at),
|
||||
-- For suppression lookup by type+name
|
||||
INDEX idx_sup_lookup (active, target_type, target_name, target_detail)
|
||||
) ENGINE=InnoDB;
|
||||
|
||||
-- ── WAN modem optical history (one row per poll) ──────────────────────
|
||||
-- Also created automatically at monitor startup (db.ensure_modem_schema).
|
||||
CREATE TABLE IF NOT EXISTS modem_samples (
|
||||
sampled_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP PRIMARY KEY,
|
||||
rx_power_dbm DECIMAL(5,1) NULL,
|
||||
tx_power_dbm DECIMAL(5,1) NULL,
|
||||
temp_c DECIMAL(5,1) NULL
|
||||
) ENGINE=InnoDB;
|
||||
|
||||
-- ── Monitor state (key/value store for snapshot + baseline) ───────────
|
||||
CREATE TABLE IF NOT EXISTS monitor_state (
|
||||
key_name VARCHAR(100) PRIMARY KEY,
|
||||
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;
|
||||
@@ -0,0 +1,19 @@
|
||||
# Demo environment (for README screenshots)
|
||||
|
||||
Fictional data only (RFC 5737 documentation addresses). A throwaway MariaDB on loopback, the Flask app, and a tiny mock of the PULSE internal API so the **Run Diagnostics** button works.
|
||||
|
||||
```bash
|
||||
D=$(mktemp -d); rsync -a --exclude .git . $D/gandalf && cd $D
|
||||
mariadb-install-db --no-defaults --datadir=$D/db --auth-root-authentication-method=normal --skip-test-db
|
||||
mariadbd --no-defaults --datadir=$D/db --socket=$D/sock --port=3398 --bind-address=127.0.0.1 --user=root &
|
||||
mariadb --no-defaults -S $D/sock -e "CREATE USER 'gandalf'@'127.0.0.1' IDENTIFIED BY 'demo-only'" < /dev/null
|
||||
mariadb --no-defaults -S $D/sock < gandalf/schema.sql
|
||||
mariadb --no-defaults -S $D/sock -e "GRANT ALL ON gandalf.* TO 'gandalf'@'127.0.0.1'"
|
||||
# gandalf/config.json: database -> 127.0.0.1:3398 gandalf/demo-only; pulse.url -> http://127.0.0.1:8650 (api_key/worker_id any value)
|
||||
python3 gandalf/scripts/demo/seed.py # events, suppressions, snapshot and link stats
|
||||
python3 gandalf/scripts/demo/mock_pulse.py & # canned diagnostics output
|
||||
(cd gandalf && gunicorn -b 127.0.0.1:8500 app:app) &
|
||||
python3 gandalf/scripts/demo/capture.py # screenshots + GIF -> docs/img/
|
||||
```
|
||||
|
||||
The app trusts Authelia `Remote-User` / `Remote-Groups` headers, so `capture.py` sends them directly. Requires `playwright` and `pillow`.
|
||||
@@ -0,0 +1,159 @@
|
||||
"""Regenerates docs/img/* from a LOCAL demo instance (fictional data). See README.md in this folder."""
|
||||
|
||||
# flake8: noqa: E501 (demo data and canned output contain long literal lines)
|
||||
|
||||
import asyncio
|
||||
import io
|
||||
import pathlib
|
||||
import sys
|
||||
from urllib.parse import quote
|
||||
|
||||
from PIL import Image
|
||||
from playwright.async_api import async_playwright
|
||||
|
||||
OUT = str(pathlib.Path(__file__).resolve().parents[2] / "docs" / "img")
|
||||
B = "http://127.0.0.1:8500"
|
||||
H = {
|
||||
"Remote-User": "alex.rivera",
|
||||
"Remote-Name": "Alex Rivera",
|
||||
"Remote-Email": "alex@example.com",
|
||||
"Remote-Groups": "admin",
|
||||
}
|
||||
TOP = (
|
||||
"document.activeElement&&document.activeElement.blur();"
|
||||
"document.documentElement.style.scrollBehavior='auto';window.scrollTo(0,0)"
|
||||
)
|
||||
AV = (
|
||||
'<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64">'
|
||||
'<rect width="64" height="64" fill="#050a10"/>'
|
||||
'<text x="32" y="40" font-family="monospace" font-size="24" font-weight="700" fill="#00d4ff" text-anchor="middle">AR</text></svg>'
|
||||
)
|
||||
|
||||
|
||||
async def mk(p, theme="dark", w=1440, h=900):
|
||||
b = await p.chromium.launch()
|
||||
c = await b.new_context(viewport={"width": w, "height": h}, extra_http_headers=H)
|
||||
await c.add_init_script(f"try{{localStorage.setItem('lt_theme','{theme}')}}catch(e){{}}")
|
||||
|
||||
async def av(route):
|
||||
await route.fulfill(status=200, content_type="image/svg+xml", body=AV)
|
||||
|
||||
await c.route("**/api/avatar*", av)
|
||||
return b, c
|
||||
|
||||
|
||||
async def go(pg, path, wait=5500):
|
||||
await pg.goto(B + path)
|
||||
await pg.wait_for_timeout(wait)
|
||||
await pg.evaluate(TOP)
|
||||
await pg.wait_for_timeout(300)
|
||||
|
||||
|
||||
async def el(pg, sel, name, idx=0):
|
||||
loc = pg.locator(sel).nth(idx)
|
||||
await loc.scroll_into_view_if_needed()
|
||||
await pg.wait_for_timeout(300)
|
||||
await loc.screenshot(path=f"{OUT}/{name}.png")
|
||||
print(name, "ok")
|
||||
|
||||
|
||||
async def select_port(pg, sw, idx):
|
||||
await pg.locator(f'[data-action="select-port"][data-switch="{sw}"][data-port-idx="{idx}"]').first.click()
|
||||
await pg.wait_for_timeout(1200)
|
||||
|
||||
|
||||
async def shots():
|
||||
async with async_playwright() as p:
|
||||
b, c = await mk(p)
|
||||
pg = await c.new_page()
|
||||
errs = []
|
||||
pg.on("pageerror", lambda e: errs.append(str(e)[:100]))
|
||||
await go(pg, "/")
|
||||
await pg.screenshot(path=f"{OUT}/dashboard.png")
|
||||
print("dashboard ok")
|
||||
await el(pg, "#topology-diagram", "topology")
|
||||
await el(pg, ".lt-section-header >> text=ALERT QUEUE", "alerts-tmp") if False else None
|
||||
# host cards + unifi table via element crops
|
||||
hb = (
|
||||
await pg.locator("#hosts-grid, .host-grid, .hosts-grid").first.bounding_box()
|
||||
if await pg.locator("#hosts-grid, .host-grid, .hosts-grid").count()
|
||||
else None
|
||||
)
|
||||
if hb:
|
||||
await pg.locator("#hosts-grid, .host-grid, .hosts-grid").first.screenshot(path=f"{OUT}/host-cards.png")
|
||||
print("host-cards ok")
|
||||
await go(pg, "/device/large1")
|
||||
await pg.locator('.device-row-toggle[data-row="enp5s0"]').click()
|
||||
await pg.wait_for_timeout(300)
|
||||
await pg.screenshot(path=f"{OUT}/device-host.png", full_page=True)
|
||||
await go(pg, "/device/" + quote("Pro 24 PoE"))
|
||||
await pg.screenshot(path=f"{OUT}/device-switch.png", full_page=True)
|
||||
await go(pg, "/device/USW-Aggregation")
|
||||
await pg.screenshot(path=f"{OUT}/inspector.png")
|
||||
await select_port(pg, "USW-Aggregation", 4)
|
||||
await pg.screenshot(path=f"{OUT}/inspector-port.png", full_page=False)
|
||||
await pg.locator('[data-action="run-diagnostic"]').first.click()
|
||||
await pg.wait_for_timeout(9000)
|
||||
await pg.evaluate("document.getElementById('diag-results')?.scrollIntoView({block:'start'})")
|
||||
await pg.wait_for_timeout(600)
|
||||
await pg.screenshot(path=f"{OUT}/inspector-diagnostics.png")
|
||||
print("diagnostics ok")
|
||||
await go(pg, "/suppressions")
|
||||
await pg.screenshot(path=f"{OUT}/suppressions.png", full_page=True)
|
||||
print("errors", errs[:3])
|
||||
await b.close()
|
||||
b, c = await mk(p, "light")
|
||||
pg = await c.new_page()
|
||||
await go(pg, "/")
|
||||
await pg.screenshot(path=f"{OUT}/dashboard-light.png")
|
||||
await b.close()
|
||||
|
||||
|
||||
async def gif():
|
||||
frames = []
|
||||
async with async_playwright() as p:
|
||||
b, c = await mk(p, "dark", 1280, 720)
|
||||
pg = await c.new_page()
|
||||
|
||||
async def snap(n=1, ms=0):
|
||||
if ms:
|
||||
await pg.wait_for_timeout(ms)
|
||||
im = Image.open(io.BytesIO(await pg.screenshot())).convert("RGB").resize((960, 540), Image.LANCZOS)
|
||||
for _ in range(n):
|
||||
frames.append(im)
|
||||
|
||||
await go(pg, "/", 5000)
|
||||
await snap(3)
|
||||
await pg.mouse.wheel(0, 620)
|
||||
await snap(3, 600)
|
||||
await pg.mouse.wheel(0, 700)
|
||||
await snap(2, 600)
|
||||
await go(pg, "/device/large1", 4500)
|
||||
await snap(3)
|
||||
await pg.mouse.wheel(0, 500)
|
||||
await snap(2, 500)
|
||||
await go(pg, "/device/USW-Aggregation", 4000)
|
||||
await snap(2)
|
||||
await select_port(pg, "USW-Aggregation", 4)
|
||||
await snap(3)
|
||||
await pg.locator('[data-action="run-diagnostic"]').first.click()
|
||||
await snap(2, 1500)
|
||||
await snap(2, 7500)
|
||||
await pg.evaluate("document.getElementById('diag-results')?.scrollIntoView({block:'start'})")
|
||||
await snap(4, 600)
|
||||
await go(pg, "/suppressions", 4000)
|
||||
await snap(3)
|
||||
await b.close()
|
||||
pal = [f.quantize(colors=96, method=Image.MEDIANCUT, dither=Image.NONE) for f in frames]
|
||||
pal[0].save(f"{OUT}/demo.gif", save_all=True, append_images=pal[1:], duration=1100, loop=0, optimize=True)
|
||||
print("gif", len(frames))
|
||||
|
||||
|
||||
async def main():
|
||||
if "gif" not in sys.argv:
|
||||
await shots()
|
||||
if "shots" not in sys.argv:
|
||||
await gif()
|
||||
|
||||
|
||||
asyncio.run(main())
|
||||
@@ -0,0 +1,133 @@
|
||||
"""Minimal stand-in for the PULSE internal API, returning canned diagnostics output (fictional data)."""
|
||||
|
||||
# flake8: noqa: E501 (demo data and canned output contain long literal lines)
|
||||
|
||||
import json
|
||||
from http.server import BaseHTTPRequestHandler, HTTPServer
|
||||
|
||||
CANNED = """=== carrier ===
|
||||
1
|
||||
=== operstate ===
|
||||
up
|
||||
=== sysfs_stats ===
|
||||
rx_bytes:9183029113
|
||||
tx_bytes:7732918231
|
||||
rx_errors:14
|
||||
tx_errors:0
|
||||
rx_dropped:0
|
||||
tx_dropped:0
|
||||
rx_crc_errors:14
|
||||
rx_frame_errors:0
|
||||
rx_fifo_errors:0
|
||||
tx_carrier_errors:0
|
||||
collisions:0
|
||||
rx_missed_errors:0
|
||||
=== carrier_changes ===
|
||||
6
|
||||
=== ethtool ===
|
||||
Settings for enp5s0:
|
||||
Supported ports: [ FIBRE ]
|
||||
Supported link modes: 10000baseT/Full
|
||||
Speed: 10000Mb/s
|
||||
Duplex: Full
|
||||
Port: FIBRE
|
||||
PHYAD: 0
|
||||
Auto-negotiation: off
|
||||
Link detected: yes
|
||||
=== ethtool_driver ===
|
||||
driver: ixgbe
|
||||
version: 6.8.12-4-pve
|
||||
firmware-version: 0x800003e1, 1.3429.0
|
||||
bus-info: 0000:05:00.0
|
||||
=== ethtool_pause ===
|
||||
Pause parameters for enp5s0:
|
||||
Autonegotiate: off
|
||||
RX: off
|
||||
TX: off
|
||||
=== ethtool_ring ===
|
||||
Ring parameters for enp5s0:
|
||||
Pre-set maximums:
|
||||
RX: 8192
|
||||
RX Mini: n/a
|
||||
RX Jumbo: n/a
|
||||
TX: 8192
|
||||
Current hardware settings:
|
||||
RX: 512
|
||||
RX Mini: n/a
|
||||
RX Jumbo: n/a
|
||||
TX: 512
|
||||
=== ethtool_stats ===
|
||||
NIC statistics:
|
||||
rx_packets: 183029113
|
||||
tx_packets: 120918231
|
||||
rx_errors: 14
|
||||
tx_errors: 0
|
||||
rx_crc_errors: 14
|
||||
rx_missed_errors: 0
|
||||
tx_timeout_count: 0
|
||||
fdir_match: 41022
|
||||
tx_flow_control_xon: 0
|
||||
rx_flow_control_xon: 0
|
||||
=== ethtool_dom ===
|
||||
Identifier : 0x03 (SFP)
|
||||
Connector : 0x07 (LC)
|
||||
Vendor name : FS
|
||||
Vendor PN : SFP-10GSR-85
|
||||
Laser wavelength : 850nm
|
||||
Laser bias current : 6.100 mA
|
||||
Laser output power : 0.5530 mW / -2.57 dBm
|
||||
Receiver signal average optical power : 0.0120 mW / -19.21 dBm
|
||||
Module temperature : 47.50 degrees C / 117.50 degrees F
|
||||
Module voltage : 3.3120 V
|
||||
=== ip_link ===
|
||||
5: enp5s0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 9000 qdisc mq master vmbr1 state UP mode DEFAULT group default qlen 1000
|
||||
link/ether 02:00:5e:10:00:05 brd ff:ff:ff:ff:ff:ff
|
||||
RX: bytes packets errors dropped missed mcast
|
||||
9183029113 183029113 14 0 0 10234
|
||||
TX: bytes packets errors dropped carrier collsns
|
||||
7732918231 120918231 0 0 0 0
|
||||
=== ip_addr ===
|
||||
5: enp5s0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 9000 qdisc mq master vmbr1 state UP group default qlen 1000
|
||||
link/ether 02:00:5e:10:00:05 brd ff:ff:ff:ff:ff:ff
|
||||
=== ip_route ===
|
||||
=== dmesg ===
|
||||
[ 412.118233] ixgbe 0000:05:00.0 enp5s0: NIC Link is Up 10 Gbps, Flow Control: None
|
||||
[1188221.402917] ixgbe 0000:05:00.0 enp5s0: NIC Link is Down
|
||||
[1188224.190331] ixgbe 0000:05:00.0 enp5s0: NIC Link is Up 10 Gbps, Flow Control: None
|
||||
[2230418.550112] ixgbe 0000:05:00.0 enp5s0: Reset adapter
|
||||
[2230421.118904] ixgbe 0000:05:00.0 enp5s0: NIC Link is Up 10 Gbps, Flow Control: None
|
||||
=== lldpctl ===
|
||||
-------------------------------------------------------------------------------
|
||||
LLDP neighbors:
|
||||
-------------------------------------------------------------------------------
|
||||
Interface: enp5s0, via: LLDP, RID: 1, Time: 12 days, 03:11:42
|
||||
Chassis:
|
||||
ChassisID: mac aa:bb:cc:00:00:03
|
||||
SysName: USW-Aggregation
|
||||
Port:
|
||||
PortID: ifname Port 4
|
||||
=== end ===
|
||||
"""
|
||||
|
||||
|
||||
class H(BaseHTTPRequestHandler):
|
||||
def _send(self, obj, code=200):
|
||||
b = json.dumps(obj).encode()
|
||||
self.send_response(code)
|
||||
self.send_header("Content-Type", "application/json")
|
||||
self.send_header("Content-Length", str(len(b)))
|
||||
self.end_headers()
|
||||
self.wfile.write(b)
|
||||
|
||||
def do_POST(self):
|
||||
self.rfile.read(int(self.headers.get("Content-Length", 0) or 0))
|
||||
self._send({"execution_id": "demo-exec-0001"})
|
||||
|
||||
def do_GET(self):
|
||||
self._send({"status": "completed", "logs": [{"action": "command_result", "stdout": CANNED}]})
|
||||
|
||||
def log_message(self, *a):
|
||||
pass
|
||||
|
||||
|
||||
HTTPServer(("127.0.0.1", 8650), H).serve_forever()
|
||||
@@ -0,0 +1,425 @@
|
||||
"""Seed a throwaway GANDALF database with fictional data (documentation IP ranges only)."""
|
||||
|
||||
# flake8: noqa: E501 (demo data and canned output contain long literal lines)
|
||||
|
||||
import json
|
||||
import random
|
||||
from datetime import datetime, timedelta, timezone
|
||||
import pymysql
|
||||
|
||||
random.seed(11)
|
||||
conn = pymysql.connect(
|
||||
host="127.0.0.1",
|
||||
port=3398,
|
||||
user="gandalf",
|
||||
password="demo-only",
|
||||
database="gandalf",
|
||||
autocommit=True,
|
||||
charset="utf8mb4",
|
||||
)
|
||||
cur = conn.cursor()
|
||||
now = datetime.now(timezone.utc)
|
||||
|
||||
|
||||
def ts(h):
|
||||
return (now - timedelta(hours=h)).strftime("%Y-%m-%d %H:%M:%S")
|
||||
|
||||
|
||||
def state(k, v):
|
||||
cur.execute(
|
||||
"REPLACE INTO monitor_state (key_name,value) VALUES (%s,%s)", (k, v if isinstance(v, str) else json.dumps(v))
|
||||
)
|
||||
|
||||
|
||||
# ---- hosts / interfaces: (name, ip, [(iface, speed_mbps, up, kind)]) kind: rj45 | fiber | dac
|
||||
HOSTS = [
|
||||
(
|
||||
"compute-storage-01",
|
||||
"192.0.2.4",
|
||||
[("eno1", 1000, True, "rj45"), ("enp1s0f0", 10000, True, "dac"), ("enp1s0f1", 10000, True, "dac")],
|
||||
),
|
||||
("compute-storage-gpu-01", "192.0.2.10", [("enp2s0", 1000, True, "rj45"), ("enp4s0", 10000, True, "fiber")]),
|
||||
("large1", "192.0.2.2", [("enp3s0", 1000, True, "rj45"), ("enp5s0", 10000, True, "fiber")]),
|
||||
(
|
||||
"storage-01",
|
||||
"192.0.2.11",
|
||||
[("enp5s0", 1000, True, "rj45"), ("enp1s0", 10000, False, "fiber")],
|
||||
), # regression: link down
|
||||
(
|
||||
"micro1",
|
||||
"192.0.2.8",
|
||||
[("enp2s0", 1000, True, "rj45"), ("enp3s0", 1000, False, "rj45")],
|
||||
), # unused bond leg (baseline, not alerted)
|
||||
("monitor-02", "192.0.2.9", [("enp2s0", 1000, True, "rj45"), ("enp3s0", 1000, True, "rj45")]),
|
||||
]
|
||||
hosts = {}
|
||||
for name, ip, ifs in HOSTS:
|
||||
st = [u for _, _, u, _ in ifs]
|
||||
status = "up" if all(st) else ("down" if not any(st) else "degraded")
|
||||
hosts[name] = {
|
||||
"ip": ip,
|
||||
"interfaces": {i: ("up" if u else "down") for i, _, u, _ in ifs},
|
||||
"status": status,
|
||||
"source": "prometheus",
|
||||
}
|
||||
hosts["backup-01"] = {"ip": "198.51.100.20", "interfaces": {}, "status": "up", "source": "ping"}
|
||||
unifi = [
|
||||
{
|
||||
"name": "Dream Machine Pro",
|
||||
"mac": "aa:bb:cc:00:00:01",
|
||||
"ip": "192.0.2.1",
|
||||
"type": "udm",
|
||||
"model": "UDMPRO",
|
||||
"state": 1,
|
||||
"connected": True,
|
||||
},
|
||||
{
|
||||
"name": "Pro 24 PoE",
|
||||
"mac": "aa:bb:cc:00:00:02",
|
||||
"ip": "192.0.2.30",
|
||||
"type": "usw",
|
||||
"model": "US24PRO",
|
||||
"state": 1,
|
||||
"connected": True,
|
||||
},
|
||||
{
|
||||
"name": "USW-Aggregation",
|
||||
"mac": "aa:bb:cc:00:00:03",
|
||||
"ip": "192.0.2.31",
|
||||
"type": "usw",
|
||||
"model": "USL8A",
|
||||
"state": 1,
|
||||
"connected": True,
|
||||
},
|
||||
{
|
||||
"name": "UNVR Pro",
|
||||
"mac": "aa:bb:cc:00:00:04",
|
||||
"ip": "192.0.2.40",
|
||||
"type": "unvr",
|
||||
"model": "UNVRPRO",
|
||||
"state": 1,
|
||||
"connected": True,
|
||||
},
|
||||
{
|
||||
"name": "Garage AP",
|
||||
"mac": "aa:bb:cc:00:00:05",
|
||||
"ip": "192.0.2.41",
|
||||
"type": "uap",
|
||||
"model": "U6LR",
|
||||
"state": 0,
|
||||
"connected": False,
|
||||
},
|
||||
{
|
||||
"name": "Office AP",
|
||||
"mac": "aa:bb:cc:00:00:06",
|
||||
"ip": "192.0.2.42",
|
||||
"type": "uap",
|
||||
"model": "U6PRO",
|
||||
"state": 1,
|
||||
"connected": True,
|
||||
},
|
||||
]
|
||||
state("network_snapshot", {"hosts": hosts, "unifi": unifi, "updated": now.isoformat().replace("+00:00", "Z")})
|
||||
state("last_check", now.strftime("%Y-%m-%d %H:%M:%S UTC"))
|
||||
|
||||
|
||||
# ---- per-interface link stats
|
||||
def rate(speed, frac):
|
||||
return speed * 1e6 / 8 * frac
|
||||
|
||||
|
||||
link_hosts = {}
|
||||
for name, ip, ifs in HOSTS:
|
||||
d = {}
|
||||
for iface, speed, up, kind in ifs:
|
||||
e = {"host_ip": ip, "link_detected": up, "carrier_changes": random.choice([1, 2, 2, 3]) if up else 9}
|
||||
if up:
|
||||
f = random.uniform(0.01, 0.18) if speed == 1000 else random.uniform(0.04, 0.38)
|
||||
e.update(
|
||||
{
|
||||
"speed_mbps": speed,
|
||||
"duplex": "Full",
|
||||
"auto_neg": True,
|
||||
"tx_bytes_rate": rate(speed, f),
|
||||
"rx_bytes_rate": rate(speed, f * random.uniform(0.5, 1.4)),
|
||||
"tx_errs_rate": 0.0,
|
||||
"rx_errs_rate": 0.0,
|
||||
"tx_drops_rate": 0.0,
|
||||
"rx_drops_rate": 0.0,
|
||||
}
|
||||
)
|
||||
else:
|
||||
e.update(
|
||||
{
|
||||
"speed_mbps": None,
|
||||
"duplex": None,
|
||||
"auto_neg": True,
|
||||
"tx_bytes_rate": 0,
|
||||
"rx_bytes_rate": 0,
|
||||
"tx_errs_rate": 0,
|
||||
"rx_errs_rate": 0,
|
||||
"tx_drops_rate": 0,
|
||||
"rx_drops_rate": 0,
|
||||
}
|
||||
)
|
||||
if up and kind == "fiber":
|
||||
e["sfp"] = {
|
||||
"sfp_type": "SFP+ 10GBASE-SR",
|
||||
"vendor": "FS",
|
||||
"part_no": "SFP-10GSR-85",
|
||||
"temp_c": round(random.uniform(38, 47), 1),
|
||||
"tx_power_dbm": round(random.uniform(-2.8, -1.6), 2),
|
||||
"rx_power_dbm": round(random.uniform(-4.5, -3.0), 2),
|
||||
}
|
||||
if up and kind == "dac":
|
||||
e["sfp"] = {"sfp_type": "SFP+ passive DAC", "vendor": "Ubiquiti", "part_no": "UACC-DAC-SFP10-1M"}
|
||||
d[iface] = e
|
||||
link_hosts[name] = d
|
||||
# one marginal fibre (low RX power) for the warning colour
|
||||
link_hosts["large1"]["enp5s0"]["sfp"].update({"rx_power_dbm": -10.9, "temp_c": 58.4})
|
||||
link_hosts["large1"]["enp5s0"]["carrier_changes"] = 6
|
||||
|
||||
|
||||
# ---- UniFi switch ports (with LLDP neighbours = the hosts above)
|
||||
def port(idx, up, speed, sw_ip, uplink=False, media="GE", lldp=None, poe=None, frac=0.05):
|
||||
|
||||
def r():
|
||||
return rate(speed, frac * random.uniform(0.5, 1.5)) if up else 0
|
||||
|
||||
p = {
|
||||
"port_idx": idx,
|
||||
"switch_ip": sw_ip,
|
||||
"up": up,
|
||||
"speed_mbps": speed if up else 0,
|
||||
"full_duplex": up,
|
||||
"autoneg": True,
|
||||
"is_uplink": uplink,
|
||||
"media": media,
|
||||
"poe_power": poe[0] if poe else None,
|
||||
"poe_class": poe[1] if poe else None,
|
||||
"poe_max_power": poe[2] if poe else None,
|
||||
"poe_mode": "auto" if poe else "",
|
||||
"lldp": lldp,
|
||||
"tx_bytes": int(random.uniform(1e11, 9e12)) if up else 0,
|
||||
"rx_bytes": int(random.uniform(1e11, 9e12)) if up else 0,
|
||||
"tx_errors": 0,
|
||||
"rx_errors": 0,
|
||||
"tx_dropped": 0,
|
||||
"rx_dropped": 0,
|
||||
"tx_bytes_rate": r(),
|
||||
"rx_bytes_rate": r(),
|
||||
"tx_errs_rate": 0.0,
|
||||
"rx_errs_rate": 0.0,
|
||||
"tx_drops_rate": 0.0,
|
||||
"rx_drops_rate": 0.0,
|
||||
}
|
||||
return p
|
||||
|
||||
|
||||
def L(host, iface):
|
||||
return {
|
||||
"chassis_id": "aa:bb:cc:11:22:33",
|
||||
"system_name": host,
|
||||
"port_id": iface,
|
||||
"port_desc": iface,
|
||||
"mgmt_ips": [dict(HOSTS_IP)[host]] if False else [],
|
||||
}
|
||||
|
||||
|
||||
HOSTS_IP = {n: ip for n, ip, _ in HOSTS}
|
||||
pro = {}
|
||||
mgmt = [
|
||||
(1, "compute-storage-01", "eno1"),
|
||||
(2, "compute-storage-gpu-01", "enp2s0"),
|
||||
(3, "large1", "enp3s0"),
|
||||
(4, "storage-01", "enp5s0"),
|
||||
(5, "micro1", "enp2s0"),
|
||||
(6, "monitor-02", "enp2s0"),
|
||||
(7, "monitor-02", "enp3s0"),
|
||||
]
|
||||
for i in range(1, 25):
|
||||
m = [x for x in mgmt if x[0] == i]
|
||||
if m:
|
||||
pro[f"Port {i}"] = port(i, True, 1000, "192.0.2.30", lldp=L(m[0][1], m[0][2]), frac=0.06)
|
||||
elif i == 8:
|
||||
pro[f"Port {i}"] = port(i, False, 0, "192.0.2.30") # micro1 unused bond leg
|
||||
elif i in (10, 11, 12):
|
||||
pro[f"Port {i}"] = port(
|
||||
i,
|
||||
True,
|
||||
100 if i == 12 else 1000,
|
||||
"192.0.2.30",
|
||||
lldp=None,
|
||||
poe=(round(random.uniform(3, 9), 1), 4, 30.0),
|
||||
frac=0.02,
|
||||
) # APs / cameras on PoE
|
||||
elif i == 9:
|
||||
pro[f"Port {i}"] = port(
|
||||
i,
|
||||
True,
|
||||
1000,
|
||||
"192.0.2.30",
|
||||
lldp={
|
||||
"chassis_id": "aa:bb:cc:00:00:04",
|
||||
"system_name": "UNVR Pro",
|
||||
"port_id": "eth0",
|
||||
"port_desc": "eth0",
|
||||
"mgmt_ips": [],
|
||||
},
|
||||
poe=(0.0, 0, 30.0),
|
||||
frac=0.2,
|
||||
)
|
||||
else:
|
||||
pro[f"Port {i}"] = port(i, False, 0, "192.0.2.30")
|
||||
pro["Port 25"] = port(
|
||||
25,
|
||||
True,
|
||||
10000,
|
||||
"192.0.2.30",
|
||||
uplink=True,
|
||||
media="SFP+",
|
||||
lldp={
|
||||
"chassis_id": "aa:bb:cc:00:00:03",
|
||||
"system_name": "USW-Aggregation",
|
||||
"port_id": "Port 7",
|
||||
"port_desc": "Port 7",
|
||||
"mgmt_ips": [],
|
||||
},
|
||||
frac=0.08,
|
||||
)
|
||||
pro["Port 26"] = port(26, False, 0, "192.0.2.30", media="SFP+")
|
||||
agg = {}
|
||||
aggmap = [
|
||||
(1, "compute-storage-01", "enp1s0f0"),
|
||||
(2, "compute-storage-01", "enp1s0f1"),
|
||||
(3, "compute-storage-gpu-01", "enp4s0"),
|
||||
(4, "large1", "enp5s0"),
|
||||
(5, "storage-01", "enp1s0"),
|
||||
]
|
||||
for i in range(1, 9):
|
||||
m = [x for x in aggmap if x[0] == i]
|
||||
if i == 5:
|
||||
agg[f"Port {i}"] = port(i, False, 0, "192.0.2.31", media="SFP+", lldp=None) # storage-01 10G link is down
|
||||
elif m:
|
||||
agg[f"Port {i}"] = port(i, True, 10000, "192.0.2.31", media="SFP+", lldp=L(m[0][1], m[0][2]), frac=0.15)
|
||||
elif i == 7:
|
||||
agg[f"Port {i}"] = port(
|
||||
i,
|
||||
True,
|
||||
10000,
|
||||
"192.0.2.31",
|
||||
uplink=True,
|
||||
media="SFP+",
|
||||
lldp={
|
||||
"chassis_id": "aa:bb:cc:00:00:02",
|
||||
"system_name": "Pro 24 PoE",
|
||||
"port_id": "Port 25",
|
||||
"port_desc": "Port 25",
|
||||
"mgmt_ips": [],
|
||||
},
|
||||
frac=0.08,
|
||||
)
|
||||
else:
|
||||
agg[f"Port {i}"] = port(i, False, 0, "192.0.2.31", media="SFP+")
|
||||
state(
|
||||
"link_stats",
|
||||
{
|
||||
"hosts": link_hosts,
|
||||
"unifi_switches": {
|
||||
"Pro 24 PoE": {"ip": "192.0.2.30", "model": "US24PRO", "ports": pro},
|
||||
"USW-Aggregation": {"ip": "192.0.2.31", "model": "USL8A", "ports": agg},
|
||||
},
|
||||
"updated": now.strftime("%Y-%m-%d %H:%M:%S UTC"),
|
||||
},
|
||||
)
|
||||
|
||||
# ---- events
|
||||
EV = [ # type, sev, source, target, detail, desc, first_seen_h, last_seen_h, resolved_h|None, fails, ticket
|
||||
(
|
||||
"interface_down",
|
||||
"warning",
|
||||
"prometheus",
|
||||
"storage-01",
|
||||
"enp1s0",
|
||||
"Interface enp1s0 on storage-01 went down (UP -> DOWN regression).",
|
||||
3.2,
|
||||
0.0,
|
||||
None,
|
||||
5,
|
||||
"731905284",
|
||||
),
|
||||
(
|
||||
"unifi_device_offline",
|
||||
"warning",
|
||||
"unifi",
|
||||
"Garage AP",
|
||||
"uap / 192.0.2.41",
|
||||
'UniFi device "Garage AP" has been offline for 3 consecutive checks.',
|
||||
1.1,
|
||||
0.0,
|
||||
None,
|
||||
3,
|
||||
"731905301",
|
||||
),
|
||||
(
|
||||
"interface_down",
|
||||
"warning",
|
||||
"prometheus",
|
||||
"compute-storage-01",
|
||||
"enp1s0f1",
|
||||
"Interface enp1s0f1 on compute-storage-01 went down.",
|
||||
9.0,
|
||||
7.5,
|
||||
7.4,
|
||||
2,
|
||||
None,
|
||||
),
|
||||
(
|
||||
"host_unreachable",
|
||||
"warning",
|
||||
"ping",
|
||||
"backup-01",
|
||||
"198.51.100.20",
|
||||
"Host backup-01 stopped answering ping for 2 consecutive checks.",
|
||||
30.0,
|
||||
28.0,
|
||||
27.9,
|
||||
2,
|
||||
"731881772",
|
||||
),
|
||||
(
|
||||
"unifi_device_offline",
|
||||
"warning",
|
||||
"unifi",
|
||||
"Office AP",
|
||||
"uap / 192.0.2.42",
|
||||
'UniFi device "Office AP" was offline for 3 consecutive checks.',
|
||||
19.0,
|
||||
18.0,
|
||||
17.8,
|
||||
3,
|
||||
"731890014",
|
||||
),
|
||||
]
|
||||
for t, sev, src, tgt, det, desc, f, l, r, fails, tid in EV:
|
||||
cur.execute(
|
||||
"INSERT INTO network_events (event_type,severity,source_type,target_name,target_detail,description,first_seen,last_seen,resolved_at,consecutive_failures,ticket_id) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)",
|
||||
(t, sev, src, tgt, det, desc, ts(f), ts(l), ts(r) if r is not None else None, fails, tid),
|
||||
)
|
||||
# ---- suppressions (one active timed, one manual, one expired in history)
|
||||
SUP = [
|
||||
("interface", "micro1", "enp3s0", "Unused bond leg, cable not connected", "alex.rivera", 48, None, 1),
|
||||
("host", "monitor-02", "", "Planned firmware update window", "alex.rivera", 0.4, 0.6, 1),
|
||||
("unifi_device", "Office AP", "", "Replacing the access point", "sam.chen", 30, 29, 0),
|
||||
]
|
||||
for tt, tn, td, reason, by, created_h, exp_in, active in SUP:
|
||||
exp = (
|
||||
(now + timedelta(hours=exp_in)).strftime("%Y-%m-%d %H:%M:%S")
|
||||
if exp_in and exp_in > 0
|
||||
else (ts(-exp_in) if exp_in else None)
|
||||
)
|
||||
cur.execute(
|
||||
"INSERT INTO suppression_rules (target_type,target_name,target_detail,reason,suppressed_by,created_at,expires_at,active) VALUES (%s,%s,%s,%s,%s,%s,%s,%s)",
|
||||
(tt, tn, td, reason, by, ts(created_h), exp, active),
|
||||
)
|
||||
print("seeded: hosts", len(hosts), "unifi", len(unifi), "events", len(EV), "suppressions", len(SUP))
|
||||
@@ -0,0 +1,13 @@
|
||||
{
|
||||
"env": { "browser": true, "es2021": true },
|
||||
"extends": "eslint:recommended",
|
||||
"parserOptions": { "ecmaVersion": 2021, "sourceType": "script" },
|
||||
"rules": {
|
||||
"no-unused-vars": "warn",
|
||||
"no-undef": "off",
|
||||
"no-empty": "warn",
|
||||
"no-inner-declarations": "warn",
|
||||
"semi": ["error", "always"],
|
||||
"eqeqeq": "warn"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,879 @@
|
||||
'use strict';
|
||||
/* exported initDeviceSearch */
|
||||
/* global DEVICE_NAME */
|
||||
|
||||
// ── Auto-redirect on auth timeout ─────────────────────────────────────
|
||||
// Wraps fetch so a 401 (Authelia session expired) forces a full reload.
|
||||
// lt.api uses fetch internally, so this covers all API calls too.
|
||||
(function () {
|
||||
const _fetch = window.fetch;
|
||||
window.fetch = async function (...args) {
|
||||
const resp = await _fetch(...args);
|
||||
if (resp.status === 401) {
|
||||
window.location.reload();
|
||||
throw new Error('Session expired, reloading');
|
||||
}
|
||||
return resp;
|
||||
};
|
||||
})();
|
||||
|
||||
// ── 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);
|
||||
if (type === 'info') return lt.toast.info(msg);
|
||||
return lt.toast.success(msg);
|
||||
}
|
||||
|
||||
// ── Normalise UTC timestamp string for Date() parsing ─────────────────
|
||||
// Server returns "2026-03-14 14:14:21 UTC"; Date() needs ISO 8601.
|
||||
function _toIso(s) {
|
||||
if (!s) return s;
|
||||
return s.replace(' UTC', 'Z').replace(' ', 'T');
|
||||
}
|
||||
|
||||
// ── Dashboard auto-refresh ────────────────────────────────────────────
|
||||
async function refreshAll() {
|
||||
const refreshBtn = document.querySelector('[data-action="refresh"]');
|
||||
const spinner = document.getElementById('refresh-spinner');
|
||||
if (refreshBtn) refreshBtn.classList.add('is-loading');
|
||||
if (spinner) spinner.style.display = '';
|
||||
try {
|
||||
const [netResult, statusResult] = await Promise.allSettled([
|
||||
lt.api.get('/api/network'),
|
||||
lt.api.get('/api/status'),
|
||||
refreshModem(),
|
||||
refreshAttention(),
|
||||
]);
|
||||
if (netResult.status === 'fulfilled') {
|
||||
const net = netResult.value;
|
||||
updateHostGrid(net.hosts || {});
|
||||
updateUnifiTable(net.unifi || []);
|
||||
} else {
|
||||
showToast('Network data unavailable', 'warning');
|
||||
}
|
||||
if (statusResult.status === 'fulfilled') {
|
||||
const status = statusResult.value;
|
||||
updateEventsTable(status.events || [], status.total_active);
|
||||
updateFollowUp(status.stale_tickets || []);
|
||||
updateStatusBar(status.summary || {}, status.last_check || '', status.daemon_ok,
|
||||
followUpCount(status.events || [], status.stale_tickets || []),
|
||||
(status.stale_tickets || []).length > 0);
|
||||
if (typeof window.gandalfNotifUpdate === 'function') window.gandalfNotifUpdate(status.events || []);
|
||||
} else {
|
||||
showToast('Status data unavailable', 'warning');
|
||||
}
|
||||
} finally {
|
||||
if (refreshBtn) refreshBtn.classList.remove('is-loading');
|
||||
if (spinner) spinner.style.display = 'none';
|
||||
}
|
||||
}
|
||||
|
||||
// ── Needs attention ───────────────────────────────────────────────────
|
||||
const ATTENTION_GROUPS = [
|
||||
{ key: 'broken', title: 'Broken now', clear: 'Nothing broken' },
|
||||
{ key: 'tidy', title: 'Tidy up', clear: 'Records match the network' },
|
||||
];
|
||||
|
||||
async function refreshAttention() {
|
||||
const body = document.getElementById('attention-body');
|
||||
if (!body) return;
|
||||
try {
|
||||
renderAttention(body, await lt.api.get('/api/attention'));
|
||||
} catch (e) {
|
||||
body.innerHTML = `<p class="attention-empty">Couldn't gather the list: ${lt.escHtml(e.message || e)}</p>`;
|
||||
}
|
||||
}
|
||||
|
||||
function renderAttention(body, data) {
|
||||
const esc = lt.escHtml;
|
||||
body.innerHTML = ATTENTION_GROUPS.map(g => {
|
||||
const rows = data[g.key] || [];
|
||||
const list = rows.length
|
||||
? `<ul class="attention-list">${rows.map(r => `
|
||||
<li class="attention-item attention-${esc(r.severity)}">
|
||||
<a class="attention-link" href="${esc(r.href)}">${esc(r.text)}</a>
|
||||
${r.detail ? `<span class="attention-detail">${esc(r.detail)}</span>` : ''}
|
||||
</li>`).join('')}</ul>`
|
||||
: `<p class="attention-clear">✓ ${g.clear}</p>`;
|
||||
return `<div class="attention-group attention-group-${g.key}">
|
||||
<h3 class="attention-group-title">${g.title}${rows.length ? ` <span class="attention-count">${rows.length}</span>` : ''}</h3>
|
||||
${list}
|
||||
</div>`;
|
||||
}).join('');
|
||||
}
|
||||
|
||||
// Active alerts flagged stale or with a closed ticket, plus tickets left open after clearing
|
||||
function followUpCount(events, staleTickets) {
|
||||
const flagged = events.filter(e => e.severity !== 'info' &&
|
||||
((e.stale_days !== null && e.stale_days !== undefined) || e.ticket_closed)).length;
|
||||
return flagged + staleTickets.length;
|
||||
}
|
||||
|
||||
function updateStatusBar(summary, lastCheck, daemonOk, followUps = 0, hasStaleTickets = false) {
|
||||
const bar = document.querySelector('.status-chips');
|
||||
if (!bar) return;
|
||||
const chips = [];
|
||||
if (daemonOk === false) chips.push('<span class="chip chip-critical">⚠ MONITOR OFFLINE</span>');
|
||||
if (summary.critical) chips.push(`<span class="chip chip-critical">● ${summary.critical} CRITICAL</span>`);
|
||||
if (summary.warning) chips.push(`<span class="chip chip-warning">● ${summary.warning} WARNING</span>`);
|
||||
if (!summary.critical && !summary.warning && daemonOk !== false) chips.push('<span class="chip chip-ok">✔ ALL SYSTEMS NOMINAL</span>');
|
||||
if (followUps) {
|
||||
const href = hasStaleTickets ? '#followup' : '#events-table-wrap';
|
||||
chips.push(`<a class="chip chip-warning chip-followup" href="${href}">⏳ ${followUps} TO FOLLOW UP</a>`);
|
||||
}
|
||||
bar.innerHTML = chips.join('');
|
||||
|
||||
const lc = document.getElementById('last-check');
|
||||
if (lc && lastCheck) lc.textContent = lastCheck;
|
||||
|
||||
const critCount = summary.critical || 0;
|
||||
const warnCount = summary.warning || 0;
|
||||
if (critCount) document.title = `(${critCount} CRIT) GANDALF`;
|
||||
else if (warnCount) document.title = `(${warnCount} WARN) GANDALF`;
|
||||
else document.title = 'GANDALF';
|
||||
|
||||
const alertBadge = document.getElementById('alert-count-badge');
|
||||
if (alertBadge) {
|
||||
const total = critCount + warnCount;
|
||||
alertBadge.textContent = total;
|
||||
alertBadge.style.display = total ? '' : 'none';
|
||||
}
|
||||
|
||||
// Stale data banner: warn if last_check is older than 15 minutes
|
||||
let staleBanner = document.getElementById('stale-banner');
|
||||
if (lastCheck) {
|
||||
const checkAge = (Date.now() - new Date(_toIso(lastCheck))) / 1000;
|
||||
if (checkAge > 900) {
|
||||
if (!staleBanner) {
|
||||
staleBanner = document.createElement('div');
|
||||
staleBanner.id = 'stale-banner';
|
||||
staleBanner.className = 'lt-alert lt-alert--warning';
|
||||
staleBanner.innerHTML = '<span class="lt-alert-icon">⚠</span><div class="lt-alert-body"><div class="lt-alert-msg"></div></div>';
|
||||
document.querySelector('.lt-main').prepend(staleBanner);
|
||||
}
|
||||
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.`;
|
||||
staleBanner.style.display = '';
|
||||
} else if (staleBanner) {
|
||||
staleBanner.style.display = 'none';
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function updateHostGrid(hosts) {
|
||||
for (const [name, host] of Object.entries(hosts)) {
|
||||
const card = document.querySelector(`.host-card[data-host="${CSS.escape(name)}"]`);
|
||||
if (!card) continue;
|
||||
|
||||
card.className = card.className.replace(/host-card-(up|down|degraded|unknown)/g, '');
|
||||
card.classList.add(`host-card-${host.status}`);
|
||||
|
||||
const dot = card.querySelector('.host-status-dot');
|
||||
if (dot) dot.className = `host-status-dot dot-${host.status}`;
|
||||
|
||||
const ifaceList = card.querySelector('.iface-list');
|
||||
if (ifaceList && host.interfaces && Object.keys(host.interfaces).length > 0) {
|
||||
// NICs marked unused fold into one line, so the card shows what is cabled
|
||||
const all = Object.entries(host.interfaces).sort(([a], [b]) => a.localeCompare(b));
|
||||
const inUse = all.filter(([, state]) => state !== 'unused');
|
||||
const unused = all.length - inUse.length;
|
||||
ifaceList.innerHTML = inUse.map(([iface, state]) => `
|
||||
<div class="iface-row">
|
||||
<span class="iface-dot dot-${lt.escHtml(state)}"></span>
|
||||
<span class="iface-name">${lt.escHtml(iface)}</span>
|
||||
<span class="iface-state state-${lt.escHtml(state)}">${lt.escHtml(state)}</span>
|
||||
</div>
|
||||
`).join('') + (unused ? `<div class="iface-unused">+${unused} unused</div>` : '');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ── Device search ─────────────────────────────────────────────────────
|
||||
function deviceUrl(name) {
|
||||
return `/device/${encodeURIComponent(name)}`;
|
||||
}
|
||||
|
||||
// All words must match somewhere; the device's name matching ranks first.
|
||||
function rankDevices(devices, query) {
|
||||
const words = query.trim().toLowerCase().split(/\s+/).filter(Boolean);
|
||||
if (!words.length) return [];
|
||||
const scored = [];
|
||||
for (const d of devices) {
|
||||
if (!words.every(w => d.search.includes(w))) continue;
|
||||
const name = d.name.toLowerCase();
|
||||
let score = 3;
|
||||
if (name === words[0]) score = 0;
|
||||
else if (name.startsWith(words[0])) score = 1;
|
||||
else if (name.includes(words[0]) || (d.ip || '').startsWith(words[0])) score = 2;
|
||||
scored.push({ d, score });
|
||||
}
|
||||
return scored
|
||||
.sort((a, b) => a.score - b.score || a.d.name.localeCompare(b.d.name))
|
||||
.slice(0, 12)
|
||||
.map(s => s.d);
|
||||
}
|
||||
|
||||
function initDeviceSearch() {
|
||||
const input = document.getElementById('device-search-input');
|
||||
const results = document.getElementById('device-search-results');
|
||||
if (!input || !results) return;
|
||||
let devices = [];
|
||||
let matches = [];
|
||||
let active = 0;
|
||||
|
||||
async function loadDevices() {
|
||||
try {
|
||||
devices = (await lt.api.get('/api/devices')).devices || [];
|
||||
} catch (err) {
|
||||
console.warn('Device list unavailable', err);
|
||||
}
|
||||
}
|
||||
|
||||
function close() {
|
||||
results.hidden = true;
|
||||
input.setAttribute('aria-expanded', 'false');
|
||||
input.removeAttribute('aria-activedescendant');
|
||||
}
|
||||
|
||||
function render() {
|
||||
matches = rankDevices(devices, input.value);
|
||||
if (!input.value.trim()) { close(); return; }
|
||||
active = Math.min(active, Math.max(matches.length - 1, 0));
|
||||
results.hidden = false;
|
||||
input.setAttribute('aria-expanded', 'true');
|
||||
if (!matches.length) {
|
||||
results.innerHTML = '<div class="device-search-empty">No devices match.</div>';
|
||||
input.removeAttribute('aria-activedescendant');
|
||||
return;
|
||||
}
|
||||
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(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>
|
||||
<span class="device-search-meta">${lt.escHtml(d.ip || '')}</span>
|
||||
<span class="device-search-meta">${lt.escHtml(d.model || '')}</span>
|
||||
</a>`).join('');
|
||||
input.setAttribute('aria-activedescendant', `device-opt-${active}`);
|
||||
}
|
||||
|
||||
input.addEventListener('input', () => { active = 0; render(); });
|
||||
input.addEventListener('focus', () => { loadDevices().then(render); });
|
||||
input.addEventListener('keydown', e => {
|
||||
if (e.key === 'Escape') { close(); return; }
|
||||
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 = matches[active].url || deviceUrl(matches[active].name); }
|
||||
});
|
||||
document.addEventListener('click', e => {
|
||||
if (!e.target.closest('#device-search')) close();
|
||||
});
|
||||
document.addEventListener('keydown', e => {
|
||||
const typing = e.target.closest('input, textarea, select, [contenteditable]');
|
||||
if (e.key === '/' && !typing && !e.ctrlKey && !e.metaKey) {
|
||||
e.preventDefault();
|
||||
input.focus();
|
||||
}
|
||||
});
|
||||
loadDevices();
|
||||
}
|
||||
|
||||
// ── WAN modem / fiber panel ───────────────────────────────────────────
|
||||
async function refreshModem() {
|
||||
try {
|
||||
updateModem(await lt.api.get('/api/modem'));
|
||||
} catch (err) {
|
||||
console.warn('Modem data unavailable', err);
|
||||
}
|
||||
}
|
||||
|
||||
function _modemUptime(seconds) {
|
||||
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);
|
||||
return d ? `${d}d ${h}h` : `${h}h ${m}m`;
|
||||
}
|
||||
|
||||
function _modemRate(bytesPerSec) {
|
||||
if (bytesPerSec === null || bytesPerSec === undefined) return '-';
|
||||
const mbps = bytesPerSec * 8 / 1e6;
|
||||
return mbps >= 1000 ? `${(mbps / 1000).toFixed(2)} Gbps` : `${mbps.toFixed(1)} Mbps`;
|
||||
}
|
||||
|
||||
function _modemStat(label, value, cls, note) {
|
||||
return `
|
||||
<div class="modem-stat">
|
||||
<span class="modem-stat-label">${lt.escHtml(label)}</span>
|
||||
<span class="modem-stat-value ${cls || ''}">${lt.escHtml(String(value))}</span>
|
||||
${note ? `<span class="modem-stat-note">${lt.escHtml(note)}</span>` : ''}
|
||||
</div>`;
|
||||
}
|
||||
|
||||
function _modemOptic(label, metric, status, unit) {
|
||||
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}`);
|
||||
}
|
||||
|
||||
function _modemChart(history) {
|
||||
const points = (history || []).filter(p => p.rx_avg !== null && p.rx_avg !== undefined);
|
||||
if (points.length < 2) {
|
||||
return '<div class="modem-chart-empty">Rx power trend appears after a few polls.</div>';
|
||||
}
|
||||
const W = 600, H = 70, PAD = 4;
|
||||
const values = points.map(p => p.rx_avg);
|
||||
const low = Math.min(...values) - 0.5, high = Math.max(...values) + 0.5;
|
||||
const t0 = points[0].ts, tSpan = (points[points.length - 1].ts - t0) || 1;
|
||||
const coord = p => `${((p.ts - t0) / tSpan * W).toFixed(1)},` +
|
||||
`${(PAD + (high - p.rx_avg) / (high - low) * (H - 2 * PAD)).toFixed(1)}`;
|
||||
|
||||
// Break the line where samples are missing rather than drawing across an outage
|
||||
const gaps = points.slice(1).map((p, i) => p.ts - points[i].ts).sort((a, b) => a - b);
|
||||
const maxGap = gaps[Math.floor(gaps.length / 2)] * 3;
|
||||
const segments = [[]];
|
||||
points.forEach((p, i) => {
|
||||
if (i && p.ts - points[i - 1].ts > maxGap) segments.push([]);
|
||||
segments[segments.length - 1].push(coord(p));
|
||||
});
|
||||
const lines = segments
|
||||
.map(s => `<polyline points="${s.join(' ')}" fill="none" vector-effect="non-scaling-stroke"/>`)
|
||||
.join('');
|
||||
const summary = `range ${Math.min(...values)} to ${Math.max(...values)} dBm`;
|
||||
return `
|
||||
<div class="modem-chart">
|
||||
<div class="modem-chart-title">Rx power, last 7 days <span>${lt.escHtml(summary)}</span></div>
|
||||
<svg viewBox="0 0 ${W} ${H}" preserveAspectRatio="none" role="img"
|
||||
aria-label="Rx power trend, ${lt.escHtml(summary)}">${lines}</svg>
|
||||
</div>`;
|
||||
}
|
||||
|
||||
function _modemWhen(epochSeconds) {
|
||||
return new Date(epochSeconds * 1000).toLocaleString([], { dateStyle: 'short', timeStyle: 'short' });
|
||||
}
|
||||
|
||||
function _modemLastRestart(history) {
|
||||
const restarts = (history && history.restarts) || [];
|
||||
if (!restarts.length) return '';
|
||||
const last = restarts[restarts.length - 1];
|
||||
return `restarted ${_modemWhen(last.at)}${last.by ? ` by ${last.by}` : ''}`;
|
||||
}
|
||||
|
||||
function _modemUptimeStat(data) {
|
||||
if (data.uptime_s !== null && data.uptime_s !== undefined) {
|
||||
return _modemStat('Uptime', _modemUptime(data.uptime_s), '', _modemLastRestart(data.wan_history));
|
||||
}
|
||||
const restarts = (data.wan_history && data.wan_history.restarts) || [];
|
||||
if (!restarts.length) return '';
|
||||
const last = restarts[restarts.length - 1];
|
||||
return _modemStat('Last restart', _modemWhen(last.at), '', last.by ? `by ${last.by}` : '');
|
||||
}
|
||||
|
||||
const _PING_VERDICTS = {
|
||||
upstream: 'slow past the modem: provider side',
|
||||
gateway: 'modem fine, ours slow: delay in the modem',
|
||||
clear: 'fine',
|
||||
};
|
||||
|
||||
// Logged-in checks: NAT sessions in use, and the latest ping run from the modem itself
|
||||
function _modemChecks(c) {
|
||||
if (!c) return '';
|
||||
const ago = at => lt.time.ago(new Date(at * 1000));
|
||||
let out = '';
|
||||
if (c.nat && c.nat.available) {
|
||||
const pct = Math.round(100 * c.nat.in_use / c.nat.available);
|
||||
out += _modemStat('NAT sessions', `${c.nat.in_use.toLocaleString()} / ${c.nat.available.toLocaleString()}`,
|
||||
pct >= 80 ? 'lt-text-amber' : '', `${pct}% in use, ${ago(c.nat.at)}`);
|
||||
}
|
||||
if (c.ping) {
|
||||
const p = c.ping;
|
||||
const value = p.avg_ms === null || p.avg_ms === undefined ? 'no reply' : `${Math.round(p.avg_ms)} ms`;
|
||||
const verdict = _PING_VERDICTS[p.verdict] || '';
|
||||
out += _modemStat("Modem's own ping", value, p.verdict === 'clear' ? '' : 'lt-text-amber',
|
||||
`to ${p.target}, ${ago(p.at)}${verdict ? `: ${verdict}` : ''}`);
|
||||
}
|
||||
const fw = c.firewall && c.firewall.hours;
|
||||
if (fw && Object.keys(fw).length) {
|
||||
const sum = k => Object.values(fw).reduce((n, h) => n + (h[k] || 0), 0);
|
||||
const flood = sum('flood'), invalid = sum('invalid'), total = flood + invalid + sum('other');
|
||||
out += _modemStat('Firewall drops', `${total.toLocaleString()} in ${Object.keys(fw).length} h`, '',
|
||||
`${flood.toLocaleString()} incoming over the flood limit, ${invalid.toLocaleString()} invalid; ` +
|
||||
'at least (the log keeps 1 per 2 s)');
|
||||
}
|
||||
const sp = c.speed;
|
||||
if (sp && sp.down && sp.up) {
|
||||
out += _modemStat('AT&T speed test', `↓ ${Math.round(sp.down.mbps)} ↑ ${Math.round(sp.up.mbps)} Mbps`, '',
|
||||
`run by the modem ${sp.down.at}, ${Math.round(sp.down.latency_ms)} ms`);
|
||||
}
|
||||
if (c.error && c.error.login) {
|
||||
out += _modemStat('Modem login', 'failed', 'lt-text-red', 'check modem.access_code');
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
function _modemDuration(seconds) {
|
||||
if (seconds < 60) return `${Math.round(seconds)}s`;
|
||||
if (seconds < 3600) return `${Math.floor(seconds / 60)}m ${Math.round(seconds % 60)}s`;
|
||||
return `${Math.floor(seconds / 3600)}h ${Math.floor((seconds % 3600) / 60)}m`;
|
||||
}
|
||||
|
||||
function _modemOutages(history) {
|
||||
const outages = ((history && history.outages) || []).slice(-5).reverse();
|
||||
if (!outages.length) return '';
|
||||
const rows = outages.map(o => {
|
||||
const length = o.restored_at === null || o.restored_at === undefined
|
||||
? '<span class="lt-text-red">ongoing</span>'
|
||||
: lt.escHtml(_modemDuration(o.restored_at - o.failed_at));
|
||||
return `<li><span>${lt.escHtml(_modemWhen(o.failed_at))}</span><span>${length}</span></li>`;
|
||||
}).join('');
|
||||
return `
|
||||
<div class="modem-outages">
|
||||
<div class="modem-chart-title">Recent WAN outages</div>
|
||||
<ul>${rows}</ul>
|
||||
</div>`;
|
||||
}
|
||||
|
||||
const _QUALITY_LABELS = { ok: 'fine', latency: 'high latency', loss: 'packet loss', down: 'down' };
|
||||
|
||||
// UniFi's own internet health timeline, one block per 5 minutes, worst flag wins
|
||||
function _modemQuality(q) {
|
||||
const periods = (q && q.periods) || [];
|
||||
if (!periods.length) return '';
|
||||
const counts = { ok: 0, latency: 0, loss: 0, down: 0 };
|
||||
periods.forEach(p => { if (p.state in counts) counts[p.state] += 1; });
|
||||
const t0 = periods[0].ts, span = Math.max(periods[periods.length - 1].ts + 300 - t0, 300);
|
||||
const blocks = periods.map(p => {
|
||||
const x = (p.ts - t0) / span * 1000, w = Math.max(300 / span * 1000, 1);
|
||||
const tip = `${_modemWhen(p.ts)}: ${_QUALITY_LABELS[p.state] || p.state}`;
|
||||
return `<rect class="wq-${lt.escHtml(p.state)}" x="${x.toFixed(1)}" y="0" width="${w.toFixed(2)}" height="20">` +
|
||||
`<title>${lt.escHtml(tip)}</title></rect>`;
|
||||
}).join('');
|
||||
const flagged = ['latency', 'loss', 'down'].filter(s => counts[s])
|
||||
.map(s => `${_QUALITY_LABELS[s]} ${counts[s]}`).join(', ');
|
||||
const summary = flagged ? `${flagged} of ${periods.length} periods` : 'no problems';
|
||||
const lat = Object.entries(q.latencies || {}).sort()
|
||||
.map(([k, v]) => `${lt.escHtml(k)} ${lt.escHtml(String(v))} ms`).join(', ');
|
||||
const legend = ['latency', 'loss', 'down']
|
||||
.map(s => `<span><i class="wq-key wq-${s}"></i>${_QUALITY_LABELS[s]}</span>`).join('');
|
||||
return `
|
||||
<div class="modem-chart modem-quality">
|
||||
<div class="modem-chart-title">Internet, last 24 hours (from UniFi) <span>${lt.escHtml(summary)}</span></div>
|
||||
<svg viewBox="0 0 1000 20" preserveAspectRatio="none" role="img"
|
||||
aria-label="Internet health over the last 24 hours: ${lt.escHtml(summary)}">${blocks}</svg>
|
||||
<div class="wq-foot"><span>${lt.escHtml(_modemWhen(t0))}</span>
|
||||
<span class="wq-legend">${legend}</span><span>now</span></div>
|
||||
${lat ? `<div class="modem-stat-note">Latency now: ${lat}</div>` : ''}
|
||||
</div>`;
|
||||
}
|
||||
|
||||
// A restart from the Restart modem button: in progress, or finished in the last hour
|
||||
function _modemRestartNote(r) {
|
||||
if (!r || !r.at) return '';
|
||||
const who = r.by ? ` by ${r.by}` : '';
|
||||
if (!r.finished_at) {
|
||||
return `<div class="modem-restart-note">Restart requested${lt.escHtml(who)} ${lt.escHtml(_modemWhen(r.at))}. ` +
|
||||
`Alerts are silenced${r.kuma ? ' here and in Uptime Kuma' : ''} until the modem is back.</div>`;
|
||||
}
|
||||
if (Date.now() / 1000 - r.finished_at > 3600) return '';
|
||||
const how = r.back ? `back after ${_modemDuration(r.back_after_s)}` : 'did not come back within 30 minutes';
|
||||
return `<div class="modem-restart-note">Restarted${lt.escHtml(who)} ${lt.escHtml(_modemWhen(r.at))}: ` +
|
||||
`${lt.escHtml(how)}. Alerts are on again.</div>`;
|
||||
}
|
||||
|
||||
async function restartModem(btn) {
|
||||
const msg = 'Restart the AT&T modem?\n\nThe internet will be down for about 3 to 5 minutes. ' +
|
||||
'Gandalf alerts and the Uptime Kuma maintenance window are switched on first, and switched off ' +
|
||||
'again when the modem is back.';
|
||||
if (!window.confirm(msg)) return;
|
||||
btn.disabled = true;
|
||||
try {
|
||||
let res;
|
||||
try {
|
||||
res = await lt.api.post('/api/modem/restart', { confirm: true });
|
||||
} catch (err) {
|
||||
if (!String(err.message).startsWith('Uptime Kuma:')) throw err;
|
||||
if (!window.confirm(`${err.message}\n\nRestart anyway? Uptime Kuma will report the outage.`)) {
|
||||
btn.disabled = false;
|
||||
return;
|
||||
}
|
||||
res = await lt.api.post('/api/modem/restart', { confirm: true, without_kuma: true });
|
||||
}
|
||||
showToast(res.result === 'accepted' ? 'Modem restarting' : 'Restart sent; the modem dropped the connection',
|
||||
'success');
|
||||
window.location.reload();
|
||||
} catch (err) {
|
||||
btn.disabled = false;
|
||||
showToast(err.message || 'Could not restart the modem', 'error');
|
||||
}
|
||||
}
|
||||
|
||||
function updateModem(data) {
|
||||
const section = document.getElementById('modem-section');
|
||||
const body = document.getElementById('modem-body');
|
||||
if (!section || !body) return;
|
||||
section.hidden = !data.configured;
|
||||
if (!data.configured) return;
|
||||
|
||||
const restartBtn = document.getElementById('modem-restart-btn');
|
||||
if (restartBtn) {
|
||||
const pending = data.modem_restart && !data.modem_restart.finished_at;
|
||||
restartBtn.hidden = !data.can_restart;
|
||||
restartBtn.disabled = Boolean(pending);
|
||||
if (!restartBtn.dataset.bound) {
|
||||
restartBtn.dataset.bound = '1';
|
||||
restartBtn.addEventListener('click', () => restartModem(restartBtn));
|
||||
}
|
||||
}
|
||||
const restartNote = _modemRestartNote(data.modem_restart);
|
||||
|
||||
// On the dashboard, link to the modem's page. On that page, it would link to itself.
|
||||
const detailsLink = document.getElementById('modem-device-link');
|
||||
if (detailsLink && typeof DEVICE_NAME === 'undefined' && data.name) {
|
||||
detailsLink.href = deviceUrl(data.name);
|
||||
detailsLink.hidden = false;
|
||||
}
|
||||
|
||||
const title = document.getElementById('modem-title');
|
||||
|
||||
if (!data.reachable) {
|
||||
body.innerHTML = `${restartNote}
|
||||
<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>
|
||||
${_modemQuality(data.wan_quality)}
|
||||
${_modemChart(data.history)}`;
|
||||
return;
|
||||
}
|
||||
|
||||
const problems = data.wan_problems || [];
|
||||
const optics = data.optics || {};
|
||||
const status = data.optics_status || {};
|
||||
const counters = data.counters || {};
|
||||
const rates = data.rates || {};
|
||||
|
||||
if (title) {
|
||||
title.textContent = [data.model || 'AT&T Gateway', data.firmware && `fw ${data.firmware}`]
|
||||
.filter(Boolean).join(' · ');
|
||||
}
|
||||
|
||||
const errs = (counters.rx_errors || 0) + (counters.tx_errors || 0);
|
||||
const drops = (counters.rx_drops || 0) + (counters.tx_drops || 0);
|
||||
body.innerHTML = `${restartNote}
|
||||
${problems.length ? `<div class="modem-error">WAN down: ${lt.escHtml(problems.join('; '))}</div>` : ''}
|
||||
<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 || '')}
|
||||
${_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')}
|
||||
${_modemStat('Throughput', `↓ ${_modemRate(rates.rx_bytes)}`, '', `↑ ${_modemRate(rates.tx_bytes)}`)}
|
||||
${_modemStat('Errors / drops', `${errs} / ${drops}`, errs ? 'lt-text-amber' : '', 'since modem reboot')}
|
||||
${_modemUptimeStat(data)}
|
||||
${_modemChecks(data.modem_checks)}
|
||||
</div>
|
||||
${_modemQuality(data.wan_quality)}
|
||||
${_modemChart(data.history)}
|
||||
${_modemOutages(data.wan_history)}
|
||||
<div class="modem-stat-note modem-updated">Updated ${lt.escHtml(data.updated || '-')}</div>`;
|
||||
}
|
||||
|
||||
function updateUnifiTable(devices) {
|
||||
const grid = document.getElementById('unifi-grid');
|
||||
if (!grid || !devices.length) return;
|
||||
const esc = lt.escHtml;
|
||||
grid.innerHTML = devices.map(d => `
|
||||
<li class="unifi-chip${d.connected ? '' : ' unifi-chip-down'}">
|
||||
<span class="${d.connected ? 'dot-up' : 'dot-down'}" title="${d.connected ? 'Online' : 'Offline'}"></span>
|
||||
<a class="device-link unifi-chip-name" href="${esc(deviceUrl(d.name))}">${esc(d.name)}</a>
|
||||
<span class="unifi-chip-model">${esc(d.model)}</span>
|
||||
${d.connected ? '' : `<button class="lt-btn lt-btn-ghost lt-btn-sm btn-suppress" data-sup-type="unifi_device"
|
||||
data-sup-name="${esc(d.name)}" data-sup-detail="" title="Suppress alerts for ${esc(d.name)}"
|
||||
aria-label="Suppress alerts for ${esc(d.name)}">🔕</button>`}
|
||||
</li>`).join('');
|
||||
}
|
||||
|
||||
function updateEventsTable(events, totalActive) {
|
||||
const wrap = document.getElementById('events-table-wrap');
|
||||
if (!wrap) return;
|
||||
|
||||
const active = (events || []).filter(e => e.severity !== 'info');
|
||||
if (!active.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 active alerts</div></div>';
|
||||
return;
|
||||
}
|
||||
|
||||
const truncated = totalActive !== null && totalActive !== undefined && totalActive > active.length;
|
||||
const countNotice = truncated
|
||||
? `<div class="pagination-notice">Showing ${active.length} of ${totalActive} active alerts: <a href="/api/events?limit=1000">view all via API</a></div>`
|
||||
: '';
|
||||
|
||||
const rows = active.map(e => {
|
||||
const supType = e.event_type === 'unifi_device_offline' ? 'unifi_device'
|
||||
: e.event_type === 'interface_down' ? 'interface'
|
||||
: 'host';
|
||||
const ticketBase = (typeof GANDALF_CONFIG !== 'undefined' && GANDALF_CONFIG.ticket_web_url)
|
||||
? GANDALF_CONFIG.ticket_web_url : 'http://t.lotusguild.org/ticket/';
|
||||
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>`
|
||||
: '';
|
||||
const staleBadge = (e.stale_days !== null && e.stale_days !== undefined)
|
||||
? `<span class="lt-badge badge-stale" title="Active for ${Number(e.stale_days)} days with no fix yet">⏳ ${Number(e.stale_days)}d</span>`
|
||||
: '';
|
||||
const closedBadge = e.ticket_closed
|
||||
? `<span class="lt-badge badge-ticket-closed" title="Ticket #${lt.escHtml(String(e.ticket_id))} was closed in Tinker, but this alert is still active">ticket closed</span>`
|
||||
: '';
|
||||
return `
|
||||
<tr class="row-${e.severity}${e.is_suppressed ? ' row-suppressed' : ''}">
|
||||
<td data-label="Sev"><span class="lt-badge badge-${e.severity}">${e.severity}</span>${supBadge}${staleBadge}${closedBadge}</td>
|
||||
<td data-label="Type">${lt.escHtml(e.event_type.replace(/_/g,' '))}</td>
|
||||
<td data-label="Target"><strong>${lt.escHtml(e.target_name)}</strong></td>
|
||||
<td data-label="Detail">${lt.escHtml(e.target_detail || '-')}</td>
|
||||
<td data-label="Description" class="desc-cell" title="${lt.escHtml(e.description || '')}">${lt.escHtml((e.description||'').substring(0,60))}${(e.description||'').length>60?'…':''}</td>
|
||||
<td data-label="First seen" class="ts-cell" title="${lt.escHtml(e.first_seen||'')}">${lt.time.ago(_toIso(e.first_seen))}</td>
|
||||
<td data-label="Last seen" class="ts-cell" title="${lt.escHtml(e.last_seen||'')}">${lt.time.ago(_toIso(e.last_seen))}</td>
|
||||
<td data-label="Failures">${e.consecutive_failures}</td>
|
||||
<td data-label="Ticket">${ticket}</td>
|
||||
<td data-label="Actions">
|
||||
<button class="lt-btn lt-btn-ghost lt-btn-sm btn-suppress"
|
||||
data-sup-type="${lt.escHtml(supType)}"
|
||||
data-sup-name="${lt.escHtml(e.target_name)}"
|
||||
data-sup-detail="${lt.escHtml(e.target_detail||'')}"
|
||||
aria-label="Suppress alert for ${lt.escHtml(e.target_name)}">🔕</button>
|
||||
</td>
|
||||
</tr>`;
|
||||
}).join('');
|
||||
|
||||
wrap.innerHTML = `
|
||||
${countNotice}
|
||||
<div class="lt-table-wrap">
|
||||
<table class="lt-table lt-table-responsive" id="events-table">
|
||||
<caption class="lt-sr-only">Active network alerts</caption>
|
||||
<thead>
|
||||
<tr>
|
||||
<th>Sev</th><th>Type</th><th>Target</th><th>Detail</th>
|
||||
<th>Description</th><th>First Seen</th><th>Last Seen</th><th>Failures</th><th>Ticket</th><th>Actions</th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>${rows}</tbody>
|
||||
</table>
|
||||
</div>`;
|
||||
}
|
||||
|
||||
// ── Needs follow-up: tickets left open after their alert cleared ──────
|
||||
function updateFollowUp(tickets) {
|
||||
const section = document.getElementById('followup');
|
||||
const tbody = document.querySelector('#followup-table tbody');
|
||||
if (!section || !tbody) return;
|
||||
section.hidden = !tickets.length;
|
||||
const badge = document.getElementById('followup-badge');
|
||||
if (badge) badge.textContent = tickets.length;
|
||||
const ticketBase = (typeof GANDALF_CONFIG !== 'undefined' && GANDALF_CONFIG.ticket_web_url)
|
||||
? GANDALF_CONFIG.ticket_web_url : 'http://t.lotusguild.org/ticket/';
|
||||
tbody.innerHTML = tickets.map(t => `
|
||||
<tr>
|
||||
<td><a href="${lt.escHtml(ticketBase)}${lt.escHtml(String(t.ticket_id))}" target="_blank" rel="noopener"
|
||||
class="ticket-link">#${lt.escHtml(String(t.ticket_id))}</a></td>
|
||||
<td><strong>${lt.escHtml(t.target_name || '')}</strong></td>
|
||||
<td>${lt.escHtml((t.event_type || '').replace(/_/g, ' '))}${t.target_detail
|
||||
? ` <span class="lt-text-muted">${lt.escHtml(t.target_detail)}</span>` : ''}</td>
|
||||
<td class="ts-cell" title="${lt.escHtml(t.cleared_at || '')}">${lt.time.ago(_toIso(t.cleared_at))}</td>
|
||||
<td>${Number(t.events) || 0}</td>
|
||||
</tr>`).join('');
|
||||
}
|
||||
|
||||
// ── Suppression modal ─────────────────────────────────────────────────
|
||||
function openSuppressModal(type, name, detail) {
|
||||
const modal = document.getElementById('suppress-modal');
|
||||
if (!modal) return;
|
||||
|
||||
document.getElementById('sup-type').value = type;
|
||||
document.getElementById('sup-name').value = name;
|
||||
document.getElementById('sup-detail').value = detail;
|
||||
document.getElementById('sup-reason').value = '';
|
||||
document.getElementById('sup-expires').value = '';
|
||||
|
||||
updateSuppressForm();
|
||||
lt.modal.open('suppress-modal');
|
||||
|
||||
document.querySelectorAll('#suppress-modal .pill').forEach(p => {
|
||||
p.classList.remove('active');
|
||||
p.setAttribute('aria-pressed', 'false');
|
||||
});
|
||||
const manualPill = document.querySelector('#suppress-modal .pill-manual');
|
||||
if (manualPill) { manualPill.classList.add('active'); manualPill.setAttribute('aria-pressed', 'true'); }
|
||||
const hint = document.getElementById('duration-hint');
|
||||
if (hint) hint.textContent = 'Suppression will persist until manually removed.';
|
||||
}
|
||||
|
||||
function closeSuppressModal() {
|
||||
lt.modal.close('suppress-modal');
|
||||
}
|
||||
|
||||
function updateSuppressForm() {
|
||||
const type = document.getElementById('sup-type').value;
|
||||
const nameGrp = document.getElementById('sup-name-group');
|
||||
const detailGrp = document.getElementById('sup-detail-group');
|
||||
const nameInput = document.getElementById('sup-name');
|
||||
const detailInput = document.getElementById('sup-detail');
|
||||
if (nameGrp) nameGrp.style.display = (type === 'all') ? 'none' : '';
|
||||
if (detailGrp) detailGrp.style.display = (type === 'interface') ? '' : 'none';
|
||||
if (nameInput) {
|
||||
const req = (type !== 'all');
|
||||
nameInput.required = req;
|
||||
nameInput.setAttribute('aria-required', String(req));
|
||||
}
|
||||
if (detailInput) {
|
||||
const req = (type === 'interface');
|
||||
detailInput.required = req;
|
||||
detailInput.setAttribute('aria-required', String(req));
|
||||
}
|
||||
}
|
||||
|
||||
function setDuration(mins, el, opts) {
|
||||
const o = opts || {};
|
||||
const expiresEl = document.getElementById(o.expiresId || 'sup-expires');
|
||||
const pillSel = o.pillSel || '#suppress-modal .pill';
|
||||
const hint = document.getElementById(o.hintId || 'duration-hint');
|
||||
if (expiresEl) expiresEl.value = mins || '';
|
||||
document.querySelectorAll(pillSel).forEach(p => {
|
||||
p.classList.remove('active');
|
||||
p.setAttribute('aria-pressed', 'false');
|
||||
});
|
||||
if (el) { el.classList.add('active'); el.setAttribute('aria-pressed', 'true'); }
|
||||
if (hint) {
|
||||
if (mins) {
|
||||
const h = Math.floor(mins / 60), m = mins % 60;
|
||||
hint.textContent = `Expires in ${h ? h + 'h ' : ''}${m ? m + 'm' : ''}.`;
|
||||
} else {
|
||||
hint.textContent = 'Suppression will persist until manually removed.';
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async function submitSuppress(e) {
|
||||
e.preventDefault();
|
||||
const type = document.getElementById('sup-type').value;
|
||||
const name = document.getElementById('sup-name').value;
|
||||
const detail = document.getElementById('sup-detail').value;
|
||||
const reason = document.getElementById('sup-reason').value;
|
||||
const expires = document.getElementById('sup-expires').value;
|
||||
|
||||
if (!reason.trim()) { showToast('Reason is required', 'error'); return; }
|
||||
if (type !== 'all' && !name.trim()) { showToast('Target name is required', 'error'); return; }
|
||||
|
||||
try {
|
||||
await lt.api.post('/api/suppressions', {
|
||||
target_type: type,
|
||||
target_name: name,
|
||||
target_detail: detail,
|
||||
reason,
|
||||
expires_minutes: expires ? parseInt(expires) : null,
|
||||
});
|
||||
closeSuppressModal();
|
||||
showToast('Suppression applied ✔', 'success');
|
||||
setTimeout(refreshAll, 500);
|
||||
} catch (err) {
|
||||
showToast(err.message || 'Failed to apply suppression', 'error');
|
||||
}
|
||||
}
|
||||
|
||||
// ── 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);
|
||||
|
||||
// ── Global click delegation ───────────────────────────────────────────
|
||||
document.addEventListener('click', e => {
|
||||
// Refresh button
|
||||
if (e.target.closest('[data-action="refresh"]')) {
|
||||
lt.autoRefresh.now();
|
||||
return;
|
||||
}
|
||||
|
||||
// Duration pills (data-duration="" = manual/forever)
|
||||
const pill = e.target.closest('.pill[data-duration]');
|
||||
if (pill) {
|
||||
const val = pill.dataset.duration;
|
||||
setDuration(val ? parseInt(val) : null, pill);
|
||||
return;
|
||||
}
|
||||
|
||||
// Suppress buttons
|
||||
const btn = e.target.closest('.btn-suppress[data-sup-type]');
|
||||
if (btn) {
|
||||
openSuppressModal(
|
||||
btn.dataset.supType || '',
|
||||
btn.dataset.supName || '',
|
||||
btn.dataset.supDetail || '',
|
||||
);
|
||||
}
|
||||
});
|
||||
|
||||
// ── Maintenance: pause every ticket for a while (a global suppression with an expiry) ──
|
||||
(function () {
|
||||
const until = document.querySelector('.maint-banner .maint-until');
|
||||
if (until) {
|
||||
const t = new Date(until.getAttribute('datetime'));
|
||||
if (!isNaN(t)) {
|
||||
const sameDay = t.toDateString() === new Date().toDateString();
|
||||
until.textContent = sameDay
|
||||
? t.toLocaleTimeString([], { hour: 'numeric', minute: '2-digit' })
|
||||
: t.toLocaleString([], { weekday: 'short', hour: 'numeric', minute: '2-digit' });
|
||||
until.title = t.toLocaleString();
|
||||
}
|
||||
}
|
||||
|
||||
let minutes = 60;
|
||||
document.addEventListener('click', async e => {
|
||||
if (e.target.closest('[data-action="start-maintenance"]')) {
|
||||
lt.modal.open('maint-modal');
|
||||
document.getElementById('maint-reason')?.focus();
|
||||
return;
|
||||
}
|
||||
const pill = e.target.closest('.maint-pill');
|
||||
if (pill) {
|
||||
minutes = parseInt(pill.dataset.minutes, 10);
|
||||
document.querySelectorAll('.maint-pill').forEach(p => {
|
||||
const on = p === pill;
|
||||
p.classList.toggle('active', on);
|
||||
p.setAttribute('aria-pressed', String(on));
|
||||
});
|
||||
return;
|
||||
}
|
||||
const end = e.target.closest('[data-action="end-maintenance"]');
|
||||
if (end) {
|
||||
end.disabled = true;
|
||||
try {
|
||||
await lt.api.delete(`/api/suppressions/${encodeURIComponent(end.dataset.supId)}`);
|
||||
window.location.reload();
|
||||
} catch (err) {
|
||||
end.disabled = false;
|
||||
showToast(err.message || 'Could not end maintenance', 'error');
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
document.getElementById('maint-form')?.addEventListener('submit', async e => {
|
||||
e.preventDefault();
|
||||
const reason = (document.getElementById('maint-reason').value || '').trim();
|
||||
if (!reason) { showToast('Reason is required', 'error'); return; }
|
||||
const submit = e.target.querySelector('[type="submit"]');
|
||||
submit.disabled = true;
|
||||
try {
|
||||
await lt.api.post('/api/suppressions', {
|
||||
target_type: 'all', target_name: '', reason, expires_minutes: minutes,
|
||||
});
|
||||
window.location.reload();
|
||||
} catch (err) {
|
||||
submit.disabled = false;
|
||||
showToast(err.message || 'Could not start maintenance', 'error');
|
||||
}
|
||||
});
|
||||
})();
|
||||
@@ -0,0 +1,800 @@
|
||||
'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;
|
||||
document.getElementById('cs-summary').innerHTML =
|
||||
`<b class="cs-ok">${matches}</b> of ${cables.length} match what Gandalf sees`
|
||||
+ (problems ? ` · <b class="cs-bad">${problems}</b> ${problems === 1 ? 'problem' : 'problems'}` : '');
|
||||
// Each tab says how much is in it; To do counts what needs doing
|
||||
const todo = _cs.suggestions.length + portFixes() + labels;
|
||||
const tabCount = (id, n, cls) => {
|
||||
const el = document.getElementById(`cs-tabcount-${id}`);
|
||||
el.textContent = n ? String(n) : '';
|
||||
el.className = `cs-tab-count${cls ? ` ${cls}` : ''}`;
|
||||
};
|
||||
tabCount('cables', cables.length, problems ? 'cs-tab-count-bad' : '');
|
||||
tabCount('todo', todo, todo ? 'cs-tab-count-warn' : '');
|
||||
tabCount('items', _cs.items.length, '');
|
||||
}
|
||||
|
||||
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>` : ''}`;
|
||||
}
|
||||
|
||||
// ── Port names in UniFi ─────────────────────────────────────────────────
|
||||
const PORT_NAME_GROUPS = [
|
||||
['wrong', 'Named after the wrong device', 'cs-chip-bad'],
|
||||
['moved', 'Named after a device that moved', 'cs-chip-warn'],
|
||||
['empty', 'Named, but nothing is plugged in', ''],
|
||||
['unnamed', 'Unnamed, with a known device plugged in', ''],
|
||||
];
|
||||
|
||||
// Wrong and moved names are worth fixing; empty and unnamed ports are only worth a look
|
||||
function portFixes() {
|
||||
return (_cs.port_names || []).filter(r => r.kind === 'wrong' || r.kind === 'moved').length;
|
||||
}
|
||||
|
||||
function renderPortNames() {
|
||||
const rows = _cs.port_names || [];
|
||||
document.getElementById('cs-portnames-count').textContent = rows.length;
|
||||
const wrap = document.getElementById('cs-portnames');
|
||||
if (!rows.length) {
|
||||
wrap.innerHTML = emptyState('✅', 'Every port name fits what is plugged in', '');
|
||||
return;
|
||||
}
|
||||
wrap.innerHTML = PORT_NAME_GROUPS.map(([kind, title, cls]) => {
|
||||
const list = rows.filter(r => r.kind === kind);
|
||||
if (!list.length) return '';
|
||||
const table = `<div class="lt-table-wrap">
|
||||
<table class="lt-table lt-table-sm">
|
||||
<caption class="lt-sr-only">${esc(title)}</caption>
|
||||
<thead><tr><th>Switch port</th><th>Name in UniFi</th><th>What Gandalf sees</th><th>Suggested name</th></tr></thead>
|
||||
<tbody>${list.map(r => `
|
||||
<tr>
|
||||
<td>${deviceLink(r.switch)} <a class="cs-port" href="/device/${encodeURIComponent(r.switch)}#port-${esc(r.port_idx)}">port ${esc(r.port_idx)}</a></td>
|
||||
<td>${esc(r.port_name)}</td>
|
||||
<td>${esc(r.detail)}</td>
|
||||
<td>${r.suggestion ? `<code>${esc(r.suggestion)}</code>` : '<span class="val-neutral">your call</span>'}</td>
|
||||
</tr>`).join('')}
|
||||
</tbody>
|
||||
</table>
|
||||
</div>`;
|
||||
// The long, low-priority group starts folded
|
||||
const open = kind !== 'unnamed' ? ' open' : '';
|
||||
return `<details class="cs-portname-group"${open}>
|
||||
<summary><span class="cs-chip ${cls}"><b>${list.length}</b> ${esc(title)}</span></summary>${table}</details>`;
|
||||
}).join('');
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
// Panels whose every port is shown, not just the ones with something on them
|
||||
const _panelsShowAll = new Set();
|
||||
|
||||
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 = [];
|
||||
const all = _panelsShowAll.has(p.id);
|
||||
let used = 0;
|
||||
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}`];
|
||||
if (front || rear || lab) used += 1;
|
||||
else if (!all) continue;
|
||||
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>`);
|
||||
}
|
||||
const total = p.port_count || 0;
|
||||
const toggle = total && used < total
|
||||
? `<button type="button" class="cs-link-btn no-print" data-action="panel-all" data-id="${esc(p.id)}" aria-expanded="${all}">${all ? `Show only the ${used} in use` : `Show all ${total} ports`}</button>`
|
||||
: '';
|
||||
const table = rows.length ? `
|
||||
<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>` : '';
|
||||
return `
|
||||
<div class="lt-frame cs-panel" id="item-${esc(p.id)}">
|
||||
<span class="lt-frame-bl">╚</span><span class="lt-frame-br">╝</span>
|
||||
<div class="lt-section-header">${esc(p.name)}${p.rack_u ? ` · U${esc(p.rack_u)}` : ''}${p.location ? ` · ${esc(p.location)}` : ''}</div>
|
||||
<p class="cs-panel-use">${used} of ${total} ports have a cable or label${used ? '' : '; nothing documented yet'}. ${toggle}</p>
|
||||
${table}
|
||||
</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 rackText(i) {
|
||||
if (i.shelf) return `on ${esc(i.shelf)}${i.slot ? `, position ${esc(i.slot)}` : ''}`;
|
||||
if (!i.rack_u) return '-';
|
||||
const side = ({ rear: ' rear posts', full: ' full depth' }[i.mount] || '') + (i.facing === 'rear' ? ', faces rear' : '');
|
||||
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();
|
||||
renderPortNames();
|
||||
renderPanels();
|
||||
renderLabels();
|
||||
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();
|
||||
reveal(window.location.hash);
|
||||
}
|
||||
|
||||
// Open the tab holding a section, cable or item (links from the dashboard, the rack and
|
||||
// other tabs point at them), then scroll to it. Cables and items flash so they're easy to spot.
|
||||
function reveal(hash) {
|
||||
if (!hash || !/^#[\w-]+$/.test(hash)) return false;
|
||||
const el = document.getElementById(hash.slice(1));
|
||||
if (!el) return false;
|
||||
const panel = el.closest('.lt-tab-panel');
|
||||
if (panel && !panel.classList.contains('active')) lt.tabs.switch(panel.id);
|
||||
if (el.classList.contains('lt-tab-panel')) return true;
|
||||
if (/^#(cable|item)-\d+$/.test(hash)) {
|
||||
el.classList.remove('cs-flash');
|
||||
void el.offsetWidth;
|
||||
el.classList.add('cs-flash');
|
||||
el.scrollIntoView({ block: 'center' });
|
||||
} else {
|
||||
el.scrollIntoView({ block: 'start' });
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
window.addEventListener('hashchange', () => reveal(window.location.hash));
|
||||
document.addEventListener('click', e => {
|
||||
// A link to something on another tab: switch tabs even when the hash is already set
|
||||
const a = e.target.closest('a[href^="#"]');
|
||||
if (a && a.getAttribute('href').length > 1 && reveal(a.getAttribute('href'))) {
|
||||
e.preventDefault();
|
||||
history.replaceState(null, '', a.getAttribute('href'));
|
||||
}
|
||||
});
|
||||
|
||||
// ── 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', facing: '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', 'facing',
|
||||
'shelf', 'slot', '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', 'facing',
|
||||
'shelf', 'slot', '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 === 'panel-all') {
|
||||
const id = Number(btn.dataset.id);
|
||||
if (_panelsShowAll.has(id)) _panelsShowAll.delete(id); else _panelsShowAll.add(id);
|
||||
renderPanels();
|
||||
}
|
||||
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') || '',
|
||||
b_device: q.get('b_device') || '', b_port: q.get('b_port') || '', cable_type: q.get('cable_type') || '',
|
||||
});
|
||||
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());
|
||||
// The dashboard's "Needs attention" list links here with ?problems=1
|
||||
if (new URLSearchParams(window.location.search).get('problems')) document.getElementById('cs-problems-only').checked = true;
|
||||
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);
|
||||
@@ -0,0 +1,506 @@
|
||||
'use strict';
|
||||
/* 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.
|
||||
|
||||
const esc = s => lt.escHtml(String(s === null || s === undefined ? '' : s));
|
||||
|
||||
const _openRows = new Set(); // survives auto-refresh
|
||||
let _filter = 'all';
|
||||
let _query = '';
|
||||
let _device = null;
|
||||
|
||||
// ── Formatting ───────────────────────────────────────────────────────
|
||||
function fmtSpeed(mbps) {
|
||||
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}`;
|
||||
}
|
||||
|
||||
function fmtUptime(seconds) {
|
||||
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`;
|
||||
}
|
||||
|
||||
function ratePct(bytesPerSec, mbps) {
|
||||
if (!mbps || !bytesPerSec) return 0;
|
||||
return Math.min(100, (bytesPerSec * 8 / 1e6 / mbps) * 100);
|
||||
}
|
||||
|
||||
function barClass(pct, isTx) {
|
||||
if (pct > 85) return 'lt-progress--red';
|
||||
if (pct > 65) return 'lt-progress--amber';
|
||||
return isTx ? '' : 'lt-progress--cyan';
|
||||
}
|
||||
|
||||
// ── SFP/DOM value classification ─────────────────────────────────────
|
||||
function rxClass(dbm) {
|
||||
if (dbm === null || dbm === undefined) return 'val-neutral';
|
||||
if (dbm < -15) return 'val-crit';
|
||||
return dbm < -10 ? 'val-warn' : 'val-good';
|
||||
}
|
||||
function txClass(dbm) {
|
||||
if (dbm === null || dbm === undefined) return 'val-neutral';
|
||||
return dbm < -5 ? 'val-crit' : 'val-good';
|
||||
}
|
||||
function tempClass(c) {
|
||||
if (c === null || c === undefined) return 'val-neutral';
|
||||
if (c > 80) return 'val-crit';
|
||||
return c > 70 ? 'val-warn' : 'val-good';
|
||||
}
|
||||
function voltClass(v) {
|
||||
if (v === null || v === undefined) return 'val-neutral';
|
||||
if (v < 3.0 || v > 3.6) return 'val-crit';
|
||||
return (v < 3.1 || v > 3.5) ? 'val-warn' : 'val-good';
|
||||
}
|
||||
|
||||
function powerFill(cls) {
|
||||
return cls === 'val-good' ? 'power-ok' : cls === 'val-warn' ? 'power-warn' : 'power-crit';
|
||||
}
|
||||
|
||||
function badges(d) {
|
||||
const out = [];
|
||||
if ((d.tx_errs_rate || 0) > 0.001 || (d.rx_errs_rate || 0) > 0.001) out.push('<span class="link-alert-badge">ERR</span>');
|
||||
if ((d.tx_drops_rate || 0) > 0.001 || (d.rx_drops_rate || 0) > 0.001) out.push('<span class="link-alert-badge link-alert-amber">DROP</span>');
|
||||
if ((d.carrier_changes || 0) > 3) out.push('<span class="link-alert-badge link-alert-amber">FLAP</span>');
|
||||
return out.join('');
|
||||
}
|
||||
|
||||
function stat(label, valueHtml, tooltip) {
|
||||
const tip = tooltip ? ` data-tooltip="${esc(tooltip)}"` : '';
|
||||
return `<div class="link-stat"><span class="link-stat-label"${tip}>${esc(label)}</span>` +
|
||||
`<span class="link-stat-value">${valueHtml}</span></div>`;
|
||||
}
|
||||
|
||||
function trafficBars(d) {
|
||||
const tx = ratePct(d.tx_bytes_rate, d.speed_mbps), rx = ratePct(d.rx_bytes_rate, d.speed_mbps);
|
||||
const row = (label, pct, rate, isTx) => `
|
||||
<div class="traffic-row">
|
||||
<span class="traffic-label">${label}</span>
|
||||
<div class="lt-progress ${barClass(pct, isTx)}"><div class="lt-progress-bar" style="width:${pct}%"></div></div>
|
||||
<span class="traffic-value">${fmtRate(rate)}</span>
|
||||
</div>`;
|
||||
return `<div class="traffic-section">${row('TX', tx, d.tx_bytes_rate, true)}${row('RX', rx, d.rx_bytes_rate, false)}</div>`;
|
||||
}
|
||||
|
||||
function sfpPanel(s) {
|
||||
if (!s || !Object.keys(s).length) return '';
|
||||
const rx = rxClass(s.rx_power_dbm), tx = txClass(s.tx_power_dbm);
|
||||
const has = v => v !== null && v !== undefined;
|
||||
const rxPct = has(s.rx_power_dbm) ? Math.min(100, Math.max(0, (s.rx_power_dbm + 20) / 15 * 100)) : 0;
|
||||
const txPct = has(s.tx_power_dbm) ? Math.min(100, Math.max(0, (s.tx_power_dbm + 10) / 8 * 100)) : 0;
|
||||
const item = (label, cls, value, tip, pct) => `
|
||||
<div class="sfp-stat">
|
||||
<span class="sfp-stat-label" data-tooltip="${esc(tip)}">${label}</span>
|
||||
<span class="sfp-stat-value ${cls}">${value}</span>
|
||||
${pct === undefined ? '' : `<div class="power-row"><div class="power-track"><div class="power-fill ${powerFill(cls)}" style="width:${pct}%"></div></div></div>`}
|
||||
</div>`;
|
||||
const vendor = [s.vendor, s.part_no, s.sfp_type, s.connector, s.wavelength_nm && `${s.wavelength_nm} nm`]
|
||||
.filter(Boolean).map(esc).join(' / ');
|
||||
return `
|
||||
<div class="sfp-panel">
|
||||
<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('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)}
|
||||
${has(s.rx_power_dbm) && has(s.tx_power_dbm) ? item('RX−TX Δ', '', `${(s.rx_power_dbm - s.tx_power_dbm).toFixed(2)} dBm`, 'Difference between receive and transmit power.') : ''}
|
||||
</div>
|
||||
</div>`;
|
||||
}
|
||||
|
||||
// ── Normalized rows, so hosts and switches share one table ───────────
|
||||
function hostRows(interfaces) {
|
||||
return Object.entries(interfaces)
|
||||
.sort(([a], [b]) => a.localeCompare(b, undefined, { numeric: true }))
|
||||
.map(([name, d]) => {
|
||||
const mark = (_device.unused_interfaces || {})[name];
|
||||
const unused = !!mark || d.state === 'unused';
|
||||
const up = !unused && (d.state ? d.state === 'up' : d.link_detected !== false);
|
||||
return {
|
||||
id: name, label: name, up, unused, unusedReason: mark ? mark.reason : '', 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('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))}
|
||||
${stat('RX Drop/s', fmtErrors(d.rx_drops_rate))}
|
||||
</div>
|
||||
${trafficBars(d)}
|
||||
${sfpPanel(d.sfp)}`,
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
function portRows(ports) {
|
||||
return Object.entries(ports)
|
||||
.sort(([, a], [, b]) => (a.port_idx || 0) - (b.port_idx || 0))
|
||||
.map(([name, d]) => {
|
||||
return {
|
||||
id: name, label: name, num: d.port_idx, up: !!d.up, data: d,
|
||||
neighbor: d.lldp ? { name: d.lldp.system_name, port: d.lldp.port_id, chassis: d.lldp.chassis_id } : null,
|
||||
sub: [d.is_uplink ? 'uplink' : '', d.media || '', d.poe_power ? `PoE ${d.poe_power.toFixed(1)} W` : ''].filter(Boolean).join(' · '),
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
function rowHasProblem(r) {
|
||||
return !r.unused && !!badges(r.data);
|
||||
}
|
||||
|
||||
// The Health cell: an unused interface says so (with an admin toggle) instead of reporting down
|
||||
function healthCell(r) {
|
||||
if (r.unused) {
|
||||
const tip = r.unusedReason ? ` title="${esc(r.unusedReason)}"` : '';
|
||||
const btn = CAN_EDIT ? ` <button type="button" class="lt-btn lt-btn-ghost lt-btn-xs" data-unused="0" data-iface="${esc(r.id)}">In use again</button>` : '';
|
||||
return `<span class="lt-badge badge-neutral"${tip}>unused</span>${btn}`;
|
||||
}
|
||||
const state = badges(r.data) || (r.up ? '<span class="val-good">OK</span>' : '<span class="device-row-sub">down</span>');
|
||||
const btn = CAN_EDIT && !r.up && r.num === undefined
|
||||
? ` <button type="button" class="lt-btn lt-btn-ghost lt-btn-xs" data-unused="1" data-iface="${esc(r.id)}"
|
||||
title="Not meant to be up: stop alerting and stop counting it against the host">Mark unused</button>` : '';
|
||||
return state + btn;
|
||||
}
|
||||
|
||||
function renderTable(rows) {
|
||||
const q = _query.trim().toLowerCase();
|
||||
const shown = rows.filter(r => {
|
||||
if (_filter === 'up' && !r.up) return false;
|
||||
if (_filter === 'problems' && !rowHasProblem(r)) return false;
|
||||
return !q || `${r.label} ${r.num || ''} ${r.sub} ${(r.neighbor && r.neighbor.name) || ''}`.toLowerCase().includes(q);
|
||||
});
|
||||
if (!shown.length) return '<div class="lt-empty-state lt-empty-state--sm"><div class="lt-empty-state-title">Nothing matches this filter</div></div>';
|
||||
const isPorts = rows.some(r => r.num !== undefined);
|
||||
const body = shown.map(r => {
|
||||
const open = !isPorts && _openRows.has(r.id);
|
||||
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.unused ? ' device-row--unused' : (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.unused ? 'unused' : (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 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>` : ''}
|
||||
<td>${healthCell(r)}</td>
|
||||
</tr>
|
||||
${open ? `<tr class="device-row-detail"><td colspan="7">${r.detail}</td></tr>` : ''}`;
|
||||
}).join('');
|
||||
return `
|
||||
<div class="lt-table-wrap">
|
||||
<table class="lt-table device-table">
|
||||
<caption class="lt-sr-only">Interfaces</caption>
|
||||
<thead><tr>
|
||||
<th><span class="lt-sr-only">Expand</span></th><th><span class="lt-sr-only">State</span></th>
|
||||
<th>${isPorts ? 'Port' : 'Interface'}</th><th>Speed</th><th class="device-col-wide">RX</th><th class="device-col-wide">TX</th>
|
||||
${isPorts ? '<th class="device-col-wide">Neighbor</th>' : ''}<th>Health</th>
|
||||
</tr></thead>
|
||||
<tbody>${body}</tbody>
|
||||
</table>
|
||||
</div>`;
|
||||
}
|
||||
|
||||
function section(title, inner, id) {
|
||||
return `
|
||||
<section class="g-section"${id ? ` id="${id}"` : ''}>
|
||||
<div class="g-section-header"><h2 class="g-section-title">${esc(title)}</h2></div>
|
||||
<div class="lt-frame">
|
||||
<span class="lt-frame-bl">╚</span><span class="lt-frame-br">╝</span>
|
||||
${inner}
|
||||
</div>
|
||||
</section>`;
|
||||
}
|
||||
|
||||
function kvGrid(pairs) {
|
||||
return `<div class="modem-stats">${pairs.filter(([, v]) => v !== null && v !== undefined && v !== '').map(([k, v]) => `
|
||||
<div class="modem-stat"><span class="modem-stat-label">${esc(k)}</span><span class="modem-stat-value">${esc(v)}</span></div>`).join('')}</div>`;
|
||||
}
|
||||
|
||||
function renderOverview(d) {
|
||||
const info = d.info || {};
|
||||
const pct = v => (v === null || v === undefined ? null : `${v.toFixed(0)}%`);
|
||||
const temps = (info.temps || []).filter(t => t.value_c !== null).map(t => `${t.name} ${t.value_c.toFixed(0)}°C`).join(', ');
|
||||
return section('Overview', kvGrid([
|
||||
['Status', (d.status || 'unknown').toUpperCase()],
|
||||
['Type', d.kind],
|
||||
['IP', d.ip],
|
||||
['MAC', d.mac],
|
||||
['Model', d.model],
|
||||
['Firmware', info.firmware],
|
||||
['Uptime', info.uptime_s === undefined ? null : fmtUptime(info.uptime_s)],
|
||||
['CPU', pct(info.cpu_pct)],
|
||||
['Memory', pct(info.mem_pct)],
|
||||
['Clients', info.clients],
|
||||
['Temperature', temps],
|
||||
['Power draw', info.power_w === null || info.power_w === undefined ? null : `${info.power_w.toFixed(0)} W`],
|
||||
['Data source', d.source],
|
||||
]));
|
||||
}
|
||||
|
||||
function renderUplinks(d) {
|
||||
if (!(d.uplinks || []).length) return '';
|
||||
const rows = d.uplinks.map(u => `
|
||||
<tr>
|
||||
<td><span class="dot-${u.up ? 'up' : 'down'}"></span></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>
|
||||
</tr>`).join('');
|
||||
return section('Connected to', `<div class="lt-table-wrap"><table class="lt-table">
|
||||
<caption class="lt-sr-only">Switch ports this host connects to, from LLDP</caption>
|
||||
<thead><tr><th><span class="lt-sr-only">State</span></th><th>Interface</th><th>Switch</th><th>Port</th><th>Speed</th></tr></thead>
|
||||
<tbody>${rows}</tbody></table></div>`);
|
||||
}
|
||||
|
||||
function renderWan(d) {
|
||||
const wan = (d.info && d.info.wan) || {};
|
||||
const names = Object.keys(wan);
|
||||
if (!names.length) return '';
|
||||
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>`;
|
||||
}).join('');
|
||||
return section('WAN', `<div class="lt-table-wrap"><table class="lt-table">
|
||||
<caption class="lt-sr-only">WAN connections</caption>
|
||||
<thead><tr><th><span class="lt-sr-only">State</span></th><th>Connection</th><th>Speed</th><th>Latency</th><th>Availability</th></tr></thead>
|
||||
<tbody>${rows}</tbody></table></div>`);
|
||||
}
|
||||
|
||||
function renderOutlets(d) {
|
||||
const outlets = (d.info && d.info.outlets) || [];
|
||||
if (!outlets.length) return '';
|
||||
const rows = outlets.map(o => `
|
||||
<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${o.stale ? ' <span class="lt-badge" title="UniFi has been sending this same reading for a long time">stale</span>' : ''}`}</td>
|
||||
<td>${o.auto_power_cycle ? '<span class="lt-badge">auto power-cycle</span>' : ''}</td>
|
||||
</tr>`).join('');
|
||||
const since = d.info.outlets_stale_since;
|
||||
const note = since
|
||||
? `<p class="g-page-sub">The outlet readings have not changed since ${esc(since)}: UniFi is sending a frozen snapshot, so they are not live. The power draw total is live.</p>`
|
||||
: '';
|
||||
return section('Outlets', `${note}<div class="lt-table-wrap"><table class="lt-table">
|
||||
<caption class="lt-sr-only">PDU outlets</caption>
|
||||
<thead><tr><th><span class="lt-sr-only">State</span></th><th>Outlet</th><th>Name</th><th>Power</th><th></th></tr></thead>
|
||||
<tbody>${rows}</tbody></table></div>`);
|
||||
}
|
||||
|
||||
function renderEvents(events) {
|
||||
const body = !(events || []).length
|
||||
? '<div class="lt-empty-state lt-empty-state--sm"><div class="lt-empty-state-icon">✔</div><div class="lt-empty-state-title">No recorded alerts</div></div>'
|
||||
: `<div class="lt-table-wrap"><table class="lt-table">
|
||||
<caption class="lt-sr-only">Alerts for this device</caption>
|
||||
<thead><tr><th>Sev</th><th>Type</th><th>Detail</th><th>Description</th><th>First seen</th><th>State</th></tr></thead>
|
||||
<tbody>${events.map(e => `
|
||||
<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 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>`;
|
||||
const more = `<p class="g-section-more"><a href="/events?target=${encodeURIComponent(DEVICE_NAME)}&range=90d">Full alert history for ${esc(DEVICE_NAME)} →</a></p>`;
|
||||
return section('Alerts', body + more);
|
||||
}
|
||||
|
||||
function currentRows() {
|
||||
if (!_device) return [];
|
||||
if (_device.ports) return portRows(_device.ports);
|
||||
if (_device.interfaces) return hostRows(_device.interfaces);
|
||||
return [];
|
||||
}
|
||||
|
||||
function renderInterfaces() {
|
||||
const wrap = document.getElementById('device-table-wrap');
|
||||
if (!wrap) return;
|
||||
wrap.innerHTML = renderTable(currentRows());
|
||||
highlightSelectedPort();
|
||||
}
|
||||
|
||||
function updateInterfaceSection(rows, title, hasChassis) {
|
||||
const section = document.getElementById('device-ports');
|
||||
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;
|
||||
}
|
||||
const inUse = rows.filter(r => !r.unused);
|
||||
const unusedCount = rows.length - inUse.length;
|
||||
document.getElementById('device-ports-title').textContent =
|
||||
`${title} · ${inUse.filter(r => r.up).length} of ${inUse.length} up${unusedCount ? ` · ${unusedCount} unused` : ''}`;
|
||||
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 mark = e.target.closest('[data-unused]');
|
||||
if (mark) toggleUnused(mark.dataset.iface, mark.dataset.unused === '1');
|
||||
});
|
||||
|
||||
async function toggleUnused(iface, unused) {
|
||||
const url = `/api/device/${encodeURIComponent(DEVICE_NAME)}/interfaces/${encodeURIComponent(iface)}/unused`;
|
||||
try {
|
||||
if (unused) {
|
||||
const reason = window.prompt(`Why isn't ${iface} in use? (optional, e.g. "spare, never cabled")`, '');
|
||||
if (reason === null) return;
|
||||
await lt.api.put(url, { reason });
|
||||
lt.toast.success(`${iface} marked unused: it won't alert or count against ${DEVICE_NAME}`);
|
||||
} else {
|
||||
await lt.api.delete(url);
|
||||
lt.toast.success(`${iface} is in use again`);
|
||||
}
|
||||
await loadDevice();
|
||||
} catch (err) {
|
||||
lt.toast.error(err.message || 'Save failed');
|
||||
}
|
||||
}
|
||||
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'}`;
|
||||
document.getElementById('device-subtitle').textContent =
|
||||
[d.kind, d.ip, d.model].filter(Boolean).join(' · ') +
|
||||
(d.updated ? ` · updated ${new Date(_toIso(d.updated)).toLocaleTimeString()}` : '');
|
||||
|
||||
const unifi = d.source === 'unifi';
|
||||
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>`;
|
||||
|
||||
document.getElementById('device-root').innerHTML =
|
||||
renderOverview(d) +
|
||||
renderEvents(d.events) +
|
||||
renderWan(d) +
|
||||
renderUplinks(d) +
|
||||
renderOutlets(d);
|
||||
|
||||
const hasPorts = !!(d.ports && Object.keys(d.ports).length);
|
||||
// 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();
|
||||
}
|
||||
|
||||
async function loadDevice() {
|
||||
try {
|
||||
render(await lt.api.get(`/api/device/${encodeURIComponent(DEVICE_NAME)}`));
|
||||
} catch (err) {
|
||||
if (_device) {
|
||||
lt.toast.error('Could not refresh device data');
|
||||
return;
|
||||
}
|
||||
const notFound = /404|No device/.test(err.message || '');
|
||||
document.getElementById('device-root').innerHTML = `
|
||||
<div class="lt-empty-state">
|
||||
<div class="lt-empty-state-icon">✕</div>
|
||||
<div class="lt-empty-state-title">${notFound ? 'No device with this name' : 'Could not load this device'}</div>
|
||||
<div class="lt-empty-state-body">${notFound ? 'It may have been renamed, or the monitor may not have seen it yet.' : 'Check that the Gandalf service is healthy, then refresh.'}</div>
|
||||
</div>`;
|
||||
}
|
||||
}
|
||||
|
||||
document.addEventListener('click', e => {
|
||||
// Switch and router rows open the shared port panel, except when following a link
|
||||
const portRow = e.target.closest('tr.device-row[data-port-idx]');
|
||||
if (portRow && !e.target.closest('a')) {
|
||||
selectPortByIdx(_device.name, parseInt(portRow.dataset.portIdx, 10));
|
||||
return;
|
||||
}
|
||||
const toggle = e.target.closest('.device-row-toggle');
|
||||
if (toggle) {
|
||||
const id = toggle.dataset.row;
|
||||
if (_openRows.has(id)) _openRows.delete(id); else _openRows.add(id);
|
||||
renderInterfaces();
|
||||
return;
|
||||
}
|
||||
const pill = e.target.closest('[data-device-filter]');
|
||||
if (pill) {
|
||||
_filter = pill.dataset.deviceFilter;
|
||||
document.querySelectorAll('[data-device-filter]').forEach(p => {
|
||||
const on = p === pill;
|
||||
p.classList.toggle('active', on);
|
||||
p.setAttribute('aria-pressed', String(on));
|
||||
});
|
||||
renderInterfaces();
|
||||
}
|
||||
});
|
||||
|
||||
document.addEventListener('input', e => {
|
||||
if (e.target.id === 'device-table-search') {
|
||||
_query = e.target.value;
|
||||
renderInterfaces();
|
||||
}
|
||||
});
|
||||
|
||||
loadDevice();
|
||||
const _deviceInterval = window.gandalfSettings?.refreshInterval ?? 60;
|
||||
if (_deviceInterval > 0) lt.autoRefresh.start(loadDevice, Math.max(_deviceInterval, 15) * 1000);
|
||||
|
||||
window.onGandalfSettingsChanged = function (s) {
|
||||
lt.autoRefresh.stop();
|
||||
if (s.refreshInterval > 0) lt.autoRefresh.start(loadDevice, Math.max(s.refreshInterval, 15) * 1000);
|
||||
};
|
||||
@@ -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();
|
||||
@@ -0,0 +1,706 @@
|
||||
'use strict';
|
||||
/* exported renderFaceplate, faceplateScrollLeft, faceplatePortAnchor, 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"/>`;
|
||||
}
|
||||
if (kind === 'usbc-h') {
|
||||
return `<rect class="fp-usbc" width="${w}" height="${h}" rx="${h / 2}"/>
|
||||
<rect class="fp-usbc-tongue" x="4" y="${cy - 1}" width="${w - 8}" height="2" rx="1"/>`;
|
||||
}
|
||||
if (kind === 'us-bare') {
|
||||
// A US socket moulded straight into a white body (the SmartPower Strip): no face plate,
|
||||
// just a shallow recess with the two blades over the round ground
|
||||
return `<rect class="fp-outlet-bare" width="${w}" height="${h}" rx="${w / 4}"/>
|
||||
<rect class="fp-slot" x="${cx - 17}" y="${cy - 20}" width="5.5" height="17" rx=".8"/>
|
||||
<rect class="fp-slot" x="${cx + 11.5}" y="${cy - 22}" width="5.5" height="19" rx=".8"/>
|
||||
<path class="fp-slot" d="M${cx - 7} ${cy + 22} v-8 a7 7 0 0 1 14 0 v8 Z"/>`;
|
||||
}
|
||||
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${data.stale ? ' (stale reading)' : ''}`);
|
||||
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 bar UniFi prints under a group of faster ports, with its speed ("2.5G", "10G")
|
||||
function fpSpeedBar(x0, x1, y, text) {
|
||||
return `<rect class="fp-speedbar" x="${x0}" y="${y - 3}" width="${x1 - x0}" height="3" rx="1.5"/>
|
||||
<text class="fp-label fp-label-sm" x="${(x0 + x1) / 2}" y="${y + 6}" text-anchor="middle">${text}</text>`;
|
||||
}
|
||||
|
||||
// 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)}`;
|
||||
},
|
||||
},
|
||||
|
||||
// USW Pro Max 24 PoE, laid out from the CC0 NetBox devicetype-library image
|
||||
// (ubiquiti-unifi-switch-pro-max-24-poe.front.png; jack centres measured from it):
|
||||
// one row of 24 RJ45 in three groups of 8 (17-24 are 2.5G), then 2 SFP+.
|
||||
USPM24P: {
|
||||
width: 1167, height: 117, frameClass: 'fp-scroll', scrollX: 560,
|
||||
label: 'USW Pro Max 24 PoE',
|
||||
legend: [...LEGEND_RJ45, ['white', '10G'], ['poe', 'PoE in use']],
|
||||
roles: { ...roleRange(1, 16, 'RJ45 1G'), ...roleRange(17, 24, 'RJ45 2.5G'), 25: 'SFP+', 26: 'SFP+' },
|
||||
ports: [
|
||||
...[118.5, 427, 734.5].flatMap((x0, g) => Array.from({ length: 8 }, (_, i) => {
|
||||
const x = x0 + i * 37.35;
|
||||
return { idx: g * 8 + i + 1, type: 'rj45', x, y: 74, scale: 1.1, label: [x, 100] };
|
||||
})),
|
||||
...[1030, 1071].map((x, i) => ({ idx: 25 + i, type: 'sfp', x, y: 62, w: 38, h: 27,
|
||||
led: [x + 19, 54], label: [x + 19, 100] })),
|
||||
],
|
||||
decor() {
|
||||
return `${fpVents([[97, 293], [301, 498], [506, 703], [710, 906], [914, 1110]], 9, 3)}
|
||||
${fpQuadScreen(14, 27, 60)}${fpModel(44, 103, 'USW', 'Pro Max', { bolt: true })}
|
||||
${[98, 407, 714].map(x => `<rect class="fp-block" x="${x}" y="53" width="303" height="36" rx="1"/>`).join('')}
|
||||
${fpSpeedBar(714, 1017, 107, '2.5G')}${fpSpeedBar(1030, 1109, 107, '10G')}
|
||||
${fpReset(1128, 101)}`;
|
||||
},
|
||||
},
|
||||
|
||||
// USW Pro Max 48 PoE, from ubiquiti-unifi-switch-pro-max-48-poe.front.png (CC0, NetBox):
|
||||
// two rows, odd ports on top, three groups of 16 (33-48 are 2.5G), then 4 SFP+ (49-52).
|
||||
USPM48P: {
|
||||
width: 1169, height: 114, frameClass: 'fp-scroll', scrollX: 560,
|
||||
label: 'USW Pro Max 48 PoE',
|
||||
legend: [...LEGEND_RJ45, ['white', '10G'], ['poe', 'PoE in use']],
|
||||
roles: { ...roleRange(1, 32, 'RJ45 1G'), ...roleRange(33, 48, 'RJ45 2.5G'), ...roleRange(49, 52, 'SFP+') },
|
||||
ports: [
|
||||
...rj45Pairs([122, 425.5, 731].flatMap(x0 => Array.from({ length: 8 }, (_, i) => x0 + i * 36.8)),
|
||||
{ top: 38, bottom: 68, topLabel: 15, bottomLabel: 97 }),
|
||||
...sfpPairs([1033, 1075], { first: 49, top: 23, bottom: 60, w: 37, h: 27, ledY: 56, ledGap: 9,
|
||||
topLabel: 15, bottomLabel: 97 }),
|
||||
],
|
||||
decor() {
|
||||
return `${fpVents([[97, 293], [301, 498], [506, 703], [710, 906], [914, 1110]], 7, 3)}
|
||||
${fpQuadScreen(14, 25, 60)}${fpModel(44, 101, 'USW', 'Pro Max', { bolt: true })}
|
||||
${[101, 405, 711].map(x => `<rect class="fp-block" x="${x}" y="19" width="298" height="70" rx="1"/>`).join('')}
|
||||
${fpSpeedBar(711, 1009, 104, '2.5G')}${fpSpeedBar(1033, 1112, 104, '10G')}
|
||||
${fpReset(1130, 99)}`;
|
||||
},
|
||||
},
|
||||
|
||||
// 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>`;
|
||||
},
|
||||
},
|
||||
|
||||
// UniFi SmartPower Strip (USP-Strip), top face. Traced from the product render on Ubiquiti's
|
||||
// datasheet (images.salsify.com/.../046c9c047ca057faf25eb38f48c598318c9ae699.pdf, page 1) and
|
||||
// sized from its 229.5 x 111.5 mm footprint at 4 units per mm, plus the cord on the left.
|
||||
// Six AC outlets in three facing pairs (1 over 2, 3 over 4, 5 over 6), and four USB-C ports
|
||||
// that UniFi switches together as outlet 7, "USB Outlets".
|
||||
UP6: {
|
||||
width: 968, height: 446, frameClass: 'fp-desk', noBody: true,
|
||||
label: 'SmartPower Strip',
|
||||
legend: [['outlet-on', 'outlet on'], ['outlet-off', 'outlet off']],
|
||||
ports: [],
|
||||
outlets: [
|
||||
...[338, 502, 664].flatMap((cx, i) => [
|
||||
{ idx: 2 * i + 1, kind: 'us-bare', flip: true, x: cx - 33, y: 86, w: 66, h: 66, label: [cx - 16, 232] },
|
||||
{ idx: 2 * i + 2, kind: 'us-bare', x: cx - 33, y: 294, w: 66, h: 66, label: [cx + 22, 232] },
|
||||
]),
|
||||
...[84, 165, 250, 335].map((y, i) => ({
|
||||
idx: 7, kind: 'usbc-h', x: 852, y: y - 7, w: 40, h: 14, label: i === 3 ? [872, y + 46] : null,
|
||||
})),
|
||||
],
|
||||
decor({ online }) {
|
||||
const usbNums = [84, 165, 250, 335].map((y, i) =>
|
||||
`<text class="fp-label fp-label-sm" x="836" y="${y + 5}" text-anchor="middle">${i + 1}</text>`).join('');
|
||||
return `<path class="fp-cord" d="M0 223 H48"/>
|
||||
<rect class="fp-cord-boot" x="26" y="203" width="26" height="40" rx="6"/>
|
||||
<rect class="fp-body-white" x="48" y="2" width="918" height="442" rx="44"/>
|
||||
<path class="fp-strip-logo" d="M120 206 v18 a10 10 0 0 0 20 0 v-18"/>
|
||||
<rect class="fp-strip-led${online ? ' fp-strip-led-on' : ''}" x="198" y="196" width="8" height="54" rx="4"/>
|
||||
<text class="fp-label fp-label-sm" x="896" y="420" text-anchor="middle">USB-C</text>
|
||||
${usbNums}`;
|
||||
},
|
||||
},
|
||||
};
|
||||
|
||||
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 { svg, marks } = faceplateSvg(model, ctx);
|
||||
return `<div class="fp-wrap">
|
||||
<div class="fp-frame ${FACEPLATES[model].frameClass}">${svg}</div>
|
||||
</div>${faceplateLegendHtml(FACEPLATES[model], marks)}`;
|
||||
}
|
||||
|
||||
// The faceplate's SVG on its own, for drawing inside another picture (a shelf). `attrs` adds
|
||||
// attributes to the <svg> (x, y, width, height to place it). Returns { svg, marks }.
|
||||
function faceplateSvg(model, ctx, attrs = '') {
|
||||
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"/>`;
|
||||
const svg = `<svg class="fp-svg" ${attrs} 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>`;
|
||||
return { svg, marks };
|
||||
}
|
||||
|
||||
// Where a port's cable plugs in, in the faceplate's viewBox units: { x, y, face }, face 'top' for a
|
||||
// port the right way up and 'bottom' for a flipped one (the lower row). null when there is no such
|
||||
// port. A model whose one port takes any index (the PDU's management port) answers for every index.
|
||||
function faceplatePortAnchor(spec, idx) {
|
||||
const p = spec.ports.find(q => q.idx === idx) || spec.ports.find(q => q.anyPort);
|
||||
if (!p) return null;
|
||||
const face = p.flip ? 'bottom' : 'top';
|
||||
if (p.type === 'sfp') return { x: p.x + p.w / 2, y: p.y + p.h / 2, face };
|
||||
return { x: p.x, y: p.y, face };
|
||||
}
|
||||
|
||||
// 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;
|
||||
}
|
||||
|
||||
// Same fronts under the other model codes UniFi uses for these switches (non-PoE variants
|
||||
// draw the same; PoE marks simply never show)
|
||||
FACEPLATES.USPM24 = FACEPLATES.USPM24P;
|
||||
FACEPLATES.USPM48 = FACEPLATES.USPM48P;
|
||||
@@ -0,0 +1,420 @@
|
||||
'use strict';
|
||||
/* exported RACK_FRONTS, CHASSIS_FACEPLATES, rackFrontSvg, shelfSvg, SHELF_GEAR, DESK_FACEPLATES */
|
||||
// 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')}`;
|
||||
},
|
||||
},
|
||||
|
||||
// Sliger CX4712 with its coloured front fitted, as in the rack photo (wiki: rack-2026.jpg):
|
||||
// a hex-perforated panel over most of the face, the drive cages faintly visible through it,
|
||||
// black rack ears, and a power button over two USB ports at the top right.
|
||||
'sliger-cx4712-red': sligerFront('#c8161d', '#e9e5e0'),
|
||||
'sliger-cx4712-white': sligerFront('#eceae6', '#9aa0a6'),
|
||||
'sliger-cx4712-blue': sligerFront('#1f5fae', '#e9e5e0'),
|
||||
|
||||
// Ubiquiti UACC-Rack-Panel-Brush-1U, from Ubiquiti's product images (store.ui.com, UACC-Rack-Panel
|
||||
// variant Brush 1U): a light silver face with separate ear plates (two rounded slots each), a
|
||||
// recessed chamfered frame around the opening (shadowed along the top, bright bevel along the
|
||||
// bottom), and two rows of black bristles meeting at a seam along the middle.
|
||||
'uacc-brush-1u': {
|
||||
label: 'UniFi Rack Panel Brush 1U (UACC-Rack-Panel-Brush-1U)', units: 1, width: 1100, height: 105,
|
||||
draw() {
|
||||
// Bristles: each row is shaded root to tip (dark where it leaves the frame, lighter where the
|
||||
// two rows meet), with a faint strand texture on top. Strong individual strands alias into hard
|
||||
// stripes at rack size, so the texture stays low-contrast and the shading carries the look.
|
||||
// The opening runs almost the full width between the ear plates, as in Ubiquiti's image
|
||||
const strands = (y0, y1, seed) => Array.from({ length: 172 }, (_, i) => {
|
||||
const n = (i * 7919 + seed * 104729) % 97;
|
||||
return `<rect x="${60 + i * 5.7 + (n % 5) * 0.4}" y="${y0 + (n % 4)}" width="${1.4 + (n % 3) * 0.5}"
|
||||
height="${y1 - y0 - (n % 4)}" class="ub-strand" style="opacity:${0.18 + (n % 5) * 0.05}"/>`;
|
||||
}).join('');
|
||||
const slot = x => `<rect class="ua-ear-slot" x="${x - 7}" y="22" width="14" height="10" rx="5"/>
|
||||
<rect class="ua-ear-slot" x="${x - 7}" y="73" width="14" height="10" rx="5"/>`;
|
||||
return `<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="ub-row-top" x1="0" y1="0" x2="0" y2="1">
|
||||
<stop offset="0" stop-color="#08090a"/><stop offset=".7" stop-color="#1f2125"/><stop offset="1" stop-color="#34373c"/>
|
||||
</linearGradient>
|
||||
<linearGradient id="ub-row-bottom" x1="0" y1="0" x2="0" y2="1">
|
||||
<stop offset="0" stop-color="#34373c"/><stop offset=".3" stop-color="#1f2125"/><stop offset="1" stop-color="#08090a"/>
|
||||
</linearGradient></defs>
|
||||
<rect class="fp-body" width="1100" height="105" rx="3"/>
|
||||
<rect class="ua-ear-plate" x="0" y="1" width="32" height="103" rx="3"/>
|
||||
<rect class="ua-ear-plate" x="1068" y="1" width="32" height="103" rx="3"/>
|
||||
<rect class="ua-ear-seam" x="31" y="1" width="1.5" height="103"/>
|
||||
<rect class="ua-ear-seam" x="1067.5" y="1" width="1.5" height="103"/>
|
||||
${slot(16)}${slot(1084)}
|
||||
<rect class="ub-frame" x="44" y="20" width="1012" height="66" rx="7"/>
|
||||
<rect class="ub-frame-shadow" x="48" y="24" width="1004" height="7" rx="3"/>
|
||||
<rect class="ub-frame-bevel" x="48" y="77" width="1004" height="5" rx="2.5"/>
|
||||
<rect class="ub-opening" x="56" y="30" width="988" height="47" rx="2"/>
|
||||
<rect x="56" y="30" width="988" height="23.5" fill="url(#ub-row-top)"/>
|
||||
<rect x="56" y="53.5" width="988" height="23.5" fill="url(#ub-row-bottom)"/>
|
||||
${strands(31, 53, 1)}${strands(54, 76, 2)}
|
||||
<rect class="ub-seam" x="56" y="53" width="988" height="1"/>`;
|
||||
},
|
||||
},
|
||||
|
||||
// Generic servers, for gear without a specific drawing
|
||||
'server-1u': genericServer(1, 4),
|
||||
'server-2u': genericServer(2, 12),
|
||||
'server-4u': genericServer(4, 24),
|
||||
};
|
||||
|
||||
// A rack handle on a Sliger ear: a vertical bar standing off the ear on two mounts
|
||||
function sligerHandle(x) {
|
||||
const top = 70, bottom = 350;
|
||||
return `<rect class="rf-sl-mount" x="${x - 2}" y="${top - 14}" width="30" height="22" rx="4"/>
|
||||
<rect class="rf-sl-mount" x="${x - 2}" y="${bottom - 8}" width="30" height="22" rx="4"/>
|
||||
<rect class="rf-sl-handle" x="${x}" y="${top - 6}" width="26" height="${bottom - top + 12}" rx="13"/>
|
||||
<rect class="rf-sl-handle-shine" x="${x + 5}" y="${top + 6}" width="5" height="${bottom - top - 12}" rx="2.5"/>`;
|
||||
}
|
||||
|
||||
function sligerFront(colour, hole) {
|
||||
const W = 1100, H = 420;
|
||||
// Hex perforations: a pattern of hexagons cut out of the panel through a mask
|
||||
const hex = (cx, cy, r) => Array.from({ length: 6 }, (_, i) => {
|
||||
const a = Math.PI / 6 + i * Math.PI / 3;
|
||||
return `${(cx + r * Math.cos(a)).toFixed(1)},${(cy + r * Math.sin(a)).toFixed(1)}`;
|
||||
}).join(' ');
|
||||
// Hole size and pitch from the rack photo: about 20 rows of holes over the panel's height
|
||||
const r = 6.9, dx = 18, dy = 15.6;
|
||||
const holes = [];
|
||||
for (let row = 0, y = 46; y < H - 34; row++, y += dy) {
|
||||
for (let x = 82 + (row % 2 ? dx / 2 : 0); x < 925; x += dx) holes.push(`<polygon points="${hex(x, y, r)}"/>`);
|
||||
}
|
||||
const bays = Array.from({ length: 10 }, (_, i) => `<rect class="rf-sl-bay" x="${140 + i * 74}" y="120" width="44" height="250" rx="3" style="fill:${hole}"/>`).join('');
|
||||
// The cages show only faintly through the mesh
|
||||
return {
|
||||
label: 'Sliger CX4712 4U (10-bay)', units: 4, width: W, height: H,
|
||||
draw({ status }) {
|
||||
const id = `sl-${colour.slice(1)}`;
|
||||
return `<defs><mask id="${id}"><rect width="${W}" height="${H}" fill="#fff"/><g fill="#000">${holes.join('')}</g></mask></defs>
|
||||
<rect class="rf-sl-inside" x="70" y="30" width="870" height="${H - 60}"/>${bays}
|
||||
<rect class="rf-sl-ear" x="0" y="0" width="70" height="${H}" rx="4"/>
|
||||
<rect class="rf-sl-ear" x="${W - 70}" y="0" width="70" height="${H}" rx="4"/>
|
||||
${sligerHandle(14)}${sligerHandle(W - 40)}
|
||||
<rect x="52" y="10" width="${W - 104}" height="${H - 20}" rx="8" style="fill:${colour}" mask="url(#${id})"/>
|
||||
<rect class="rf-sl-edge" x="52" y="10" width="${W - 104}" height="${H - 20}" rx="8"/>
|
||||
<circle class="rf-sl-button" cx="988" cy="88" r="17"/>
|
||||
<circle class="rf-power-ring" cx="988" cy="88" r="12" style="stroke:${frontLed(status)}"/>
|
||||
<rect class="rf-sl-io" x="966" y="138" width="44" height="74" rx="4"/>
|
||||
${usbA(977, 146)}${usbA(977, 168)}${usbC(980, 192)}`;
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
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',
|
||||
// For a new switch before UniFi reports it (or under a model code not mapped yet)
|
||||
'usw-pro-max-24-poe': 'USPM24P',
|
||||
'usw-pro-max-48-poe': 'USPM48P',
|
||||
};
|
||||
|
||||
// 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>`;
|
||||
}
|
||||
|
||||
// ── IceWhale ZimaBoard 832 (shelf gear) ─────────────────────────────────
|
||||
// The port end, traced from IceWhale's labelled photo in ZimaDocs
|
||||
// (source/images/Hardware-Interface-Introduction-/hardware-interface-introduction.webp),
|
||||
// in that photo's pixel coordinates (the port end spans 862 x 415 px; 81.4 mm wide).
|
||||
// Left to right: Mini-DisplayPort 1.2, two stacks of GbE RJ45 over USB 3.0, DC 12V 5.5x2.5mm,
|
||||
// on a gunmetal case over a thin gold PCB edge and the black polycarbonate base.
|
||||
const ZIMA = { width: 862, height: 415, mm: 81.4 };
|
||||
|
||||
function zimaRj45(x, y, link) {
|
||||
const contacts = Array.from({ length: 8 }, (_, i) => `<rect class="zb-contact" x="${x + 52 + i * 14}" y="${y + 34}" width="5" height="22"/>`).join('');
|
||||
return `<rect class="zb-shield" x="${x}" y="${y}" width="207" height="143" rx="5"/>
|
||||
<rect class="zb-hole" x="${x + 22}" y="${y + 30}" width="163" height="102" rx="2"/>
|
||||
<rect class="zb-hole-key" x="${x + 70}" y="${y + 120}" width="67" height="16" rx="1"/>
|
||||
${contacts}
|
||||
<rect class="zb-led" x="${x + 16}" y="${y + 9}" width="30" height="15" rx="2" style="fill:${link ? '#3ad16b' : '#8f8f8a'}"/>
|
||||
<rect class="zb-led" x="${x + 161}" y="${y + 9}" width="30" height="15" rx="2" style="fill:${link ? '#f2d13a' : '#77714a'}"/>`;
|
||||
}
|
||||
|
||||
function zimaUsb(x, y) {
|
||||
return `<rect class="zb-shield" x="${x}" y="${y}" width="204" height="100" rx="5"/>
|
||||
<rect class="zb-hole" x="${x + 26}" y="${y + 20}" width="152" height="62" rx="2"/>
|
||||
<rect class="zb-usb-tongue" x="${x + 38}" y="${y + 28}" width="128" height="22" rx="2"/>
|
||||
${Array.from({ length: 5 }, (_, i) => `<rect class="zb-usb-pin" x="${x + 50 + i * 24}" y="${y + 46}" width="10" height="4"/>`).join('')}`;
|
||||
}
|
||||
|
||||
// Which NIC is which on a ZimaBoard: the onboard Realtek GbE ports enumerate on PCI buses 2 and 3
|
||||
// (enp2s0 left jack, enp3s0 right), and a card in the PCIe slot on bus 1 (enp1s0, enp1s0d1).
|
||||
const ZIMA_NICS = { rj45: ['enp2s0', 'enp3s0'], slot: /^enp1s0/ };
|
||||
|
||||
function zimaNic(ctx, name) {
|
||||
const n = (ctx.interfaces || []).find(i => i.name === name);
|
||||
return n ? n.up : ctx.status === 'up';
|
||||
}
|
||||
|
||||
function zimaFront(ctx) {
|
||||
// ctx: { status, interfaces: [{name, up}] }
|
||||
const link = i => zimaNic(ctx, ZIMA_NICS.rj45[i]);
|
||||
const on = ctx.status === 'up' || ctx.status === 'degraded';
|
||||
const pads = [60, 105, 420, 470, 640, 700, 790, 835]
|
||||
.map(x => `<rect class="zb-pad" x="${x}" y="309" width="12" height="7"/>`).join('');
|
||||
return `
|
||||
<rect class="zb-base" x="0" y="300" width="862" height="115" rx="10"/>
|
||||
<rect class="zb-base-sheen" x="6" y="330" width="850" height="6" rx="3"/>
|
||||
${on ? '<ellipse class="zb-glow" cx="34" cy="404" rx="34" ry="9"/>' : ''}
|
||||
<rect class="zb-pcb" x="2" y="306" width="858" height="12"/>${pads}
|
||||
<path class="zb-case" d="M0 14 Q0 0 14 0 H848 Q862 0 862 14 V308 H0 Z"/>
|
||||
<rect class="zb-case-edge" x="0" y="6" width="18" height="300"/>
|
||||
<rect class="zb-case-top" x="14" y="0" width="834" height="5"/>
|
||||
<rect class="zb-shield" x="63" y="225" width="127" height="80" rx="6"/>
|
||||
<path class="zb-hole" d="M75 243 H178 V280 L163 293 H90 L75 280 Z"/>
|
||||
<rect class="zb-dp-pins" x="92" y="262" width="69" height="9" rx="1"/>
|
||||
${zimaRj45(213, 47, link(0))}${zimaRj45(443, 47, link(1))}
|
||||
${zimaUsb(216, 205)}${zimaUsb(443, 205)}
|
||||
<rect class="zb-dc" x="678" y="177" width="132" height="130" rx="8"/>
|
||||
<rect class="zb-dc-face" x="690" y="189" width="108" height="106" rx="6"/>
|
||||
<circle class="zb-dc-ring" cx="744" cy="242" r="36"/>
|
||||
<circle class="zb-hole" cx="744" cy="242" r="27"/>
|
||||
<circle class="zb-dc-pin" cx="744" cy="242" r="8"/>`;
|
||||
}
|
||||
|
||||
// A Mellanox ConnectX-3 single-port SFP+ card (MCX311A) in the ZimaBoard's side PCIe slot, lying flat
|
||||
// beside the board as in the rack photo (wiki.lotusguild.org/zimaboards.jpg): its front edge is about
|
||||
// 54 mm (572 px at the ZimaBoard photo's 10.59 px/mm), PCB at the board's PCB height, heatsink on the
|
||||
// chip, and the SFP+ cage toward the board with a DAC plugged in and its pull tab hanging down.
|
||||
// The round dot on the cage is Gandalf's link mark (like the cutsheet marks), not an LED on the card.
|
||||
const CX3_PX = 572;
|
||||
|
||||
function cx3Card(up) {
|
||||
return `
|
||||
<rect class="cx-part" x="40" y="314" width="70" height="22" rx="2"/>
|
||||
<rect class="cx-part" x="150" y="314" width="40" height="16" rx="2"/>
|
||||
<rect class="cx-part" x="250" y="314" width="90" height="26" rx="2"/>
|
||||
<rect class="cx-pcb" x="0" y="296" width="${CX3_PX}" height="18" rx="2"/>
|
||||
<rect class="cx-pcb-edge" x="0" y="296" width="${CX3_PX}" height="4"/>
|
||||
<rect class="cx-heatsink" x="110" y="232" width="210" height="64" rx="3"/>
|
||||
${Array.from({ length: 9 }, (_, i) => `<rect class="cx-fin" x="${120 + i * 22}" y="232" width="9" height="64"/>`).join('')}
|
||||
<rect class="cx-cage" x="380" y="190" width="150" height="106" rx="4"/>
|
||||
<rect class="cx-cage-lip" x="380" y="190" width="150" height="10" rx="3"/>
|
||||
<rect class="cx-plug" x="392" y="206" width="126" height="80" rx="5"/>
|
||||
<rect class="cx-boot" x="410" y="220" width="90" height="52" rx="10"/>
|
||||
<circle class="cx-cable" cx="455" cy="246" r="20"/>
|
||||
<path class="cx-tab" d="M441 286 V392 Q441 404 455 404 Q469 404 469 392 V286"/>
|
||||
<circle class="cx-link" cx="520" cy="200" r="13" style="fill:${up ? '#3ad16b' : '#e0312b'}"><title>Gandalf: SFP+ link ${up ? 'up' : 'down'}</title></circle>`;
|
||||
}
|
||||
|
||||
function zimaCx3Front(ctx) {
|
||||
return `${cx3Card(zimaNic(ctx, (ctx.interfaces || []).map(i => i.name).find(n => ZIMA_NICS.slot.test(n)) || 'enp1s0'))}
|
||||
<g transform="translate(${CX3_PX} 0)">${zimaFront(ctx)}</g>`;
|
||||
}
|
||||
|
||||
const ZIMA_SPECS = 'Intel Celeron N3450, 8GB LPDDR4, 32GB eMMC, 2x GbE, 2x USB 3.0, 2x SATA, PCIe 2.0 x4, 6W';
|
||||
|
||||
const SHELF_GEAR = {
|
||||
'zimaboard-832': {
|
||||
label: 'IceWhale ZimaBoard 832', mm: ZIMA.mm, width: ZIMA.width, height: ZIMA.height, draw: zimaFront,
|
||||
specs: ZIMA_SPECS,
|
||||
},
|
||||
'zimaboard-832-cx3': {
|
||||
label: 'IceWhale ZimaBoard 832 + ConnectX-3 SFP+', mm: ZIMA.mm * (ZIMA.width + CX3_PX) / ZIMA.width,
|
||||
width: ZIMA.width + CX3_PX, height: ZIMA.height, draw: zimaCx3Front,
|
||||
specs: `${ZIMA_SPECS}; Mellanox ConnectX-3 10G SFP+ (enp1s0) in the PCIe slot, DAC attached`,
|
||||
},
|
||||
};
|
||||
|
||||
// UniFi desk gear drawn from its live faceplate when it sits on a shelf: the real width of the
|
||||
// face (Ubiquiti tech specs) and the span of that face in the faceplate drawing, to scale it.
|
||||
const DESK_FACEPLATES = {
|
||||
USMINI: { mm: 107, body: [2, 661], label: 'UniFi Switch Flex Mini' }, // 107 x 70 x 21 mm
|
||||
USF5P: { mm: 122.5, body: [66, 488], label: 'UniFi Switch Flex' }, // 122.5 x 107.1 x 28 mm
|
||||
};
|
||||
|
||||
// A shelf at true scale (1100 units = 482.6 mm, a 19" panel) with what sits on it, left to right.
|
||||
// Gear with a SHELF_GEAR drawing, or UniFi desk gear with a live faceplate, is drawn to its real
|
||||
// width; anything else is a labelled box. A shelf with Front drawing "resting" has no tray: its gear
|
||||
// lies directly on whatever is below it (a switch on top of the NVR).
|
||||
function shelfSvg(item, esc, faceplate) {
|
||||
const units = item.rack_height || 1;
|
||||
const W = 1100, H = 105 * units, perMm = W / 482.6;
|
||||
const resting = item.chassis === 'resting';
|
||||
const floor = resting ? H - 3 : H - 20;
|
||||
let x = 64;
|
||||
const things = (item.contents || []).map(c => {
|
||||
const gear = SHELF_GEAR[c.chassis];
|
||||
const desk = !gear && faceplate && DESK_FACEPLATES[c.model];
|
||||
let w, h, body;
|
||||
if (gear) {
|
||||
w = gear.mm * perMm;
|
||||
const k = w / gear.width;
|
||||
h = gear.height * k;
|
||||
body = `<g transform="translate(${x} ${floor - h}) scale(${k})">${gear.draw(c)}</g>`;
|
||||
} else if (desk) {
|
||||
// Scale the faceplate so its body spans the switch's real width, then place the whole drawing
|
||||
const spec = faceplate.spec(c.model);
|
||||
const k = (desk.mm * perMm) / (desk.body[1] - desk.body[0]);
|
||||
w = desk.mm * perMm;
|
||||
h = spec.height * k;
|
||||
body = faceplate.svg(c, `x="${x - desk.body[0] * k}" y="${floor - h}" width="${spec.width * k}" height="${h}"`);
|
||||
} else {
|
||||
w = 150;
|
||||
h = 58;
|
||||
body = `<rect class="sh-box" x="${x}" y="${floor - h}" width="${w}" height="${h}" rx="4"/>
|
||||
<text class="sh-box-name" x="${x + w / 2}" y="${floor - h / 2 + 5}" text-anchor="middle">${esc(c.name)}</text>`;
|
||||
}
|
||||
const top = floor - h;
|
||||
const nics = (c.interfaces || []).map(n => `${n.name} ${n.unused ? 'unused' : (n.up ? 'up' : 'down')}`).join(', ');
|
||||
const label = gear ? gear.label : (desk ? desk.label : c.kind);
|
||||
const tip = [c.name, label, c.status, nics, gear && gear.specs].filter(Boolean).join(' · ');
|
||||
// A live faceplate's ports are links of their own, so it isn't wrapped in one
|
||||
const open = desk ? '<g class="sh-thing">' : `<a class="sh-thing" href="${esc(c.url)}">`;
|
||||
const tagY = resting ? top - 16 : floor + 5;
|
||||
const out = `${open}<title>${esc(tip)}</title>
|
||||
${body}
|
||||
${desk ? '' : `<rect class="sh-hit" x="${x - 4}" y="${top - 4}" width="${w + 8}" height="${h + 8}" rx="4"/>`}
|
||||
<rect class="sh-tag" x="${x + w / 2 - 46}" y="${tagY}" width="92" height="12" rx="2"/>
|
||||
<text class="sh-tag-text" x="${x + w / 2}" y="${tagY + 9}" text-anchor="middle">${esc(c.name)}</text>
|
||||
${desk ? '</g>' : '</a>'}`;
|
||||
x += w + 26;
|
||||
return out;
|
||||
}).join('');
|
||||
const tray = resting ? '' : `${ears(W, H, 'rf-ear-dark')}
|
||||
<rect class="sh-back" x="36" y="6" width="${W - 72}" height="${floor - 6}"/>
|
||||
<rect class="sh-floor" x="30" y="${floor}" width="${W - 60}" height="${H - floor - 2}" rx="2"/>
|
||||
<rect class="sh-lip" x="30" y="${floor}" width="${W - 60}" height="3"/>`;
|
||||
return `<svg class="rack-svg rack-shelf-svg" viewBox="0 0 ${W} ${H}" preserveAspectRatio="none" role="group"
|
||||
aria-label="${esc(item.name)}">
|
||||
<title>${esc(item.name)}</title>
|
||||
${tray}
|
||||
${things || `<text class="sh-empty" x="${W / 2}" y="${floor - 12}" text-anchor="middle">${resting ? 'nothing here' : 'empty shelf'}</text>`}
|
||||
<text class="sh-name" x="46" y="18">${esc(item.name)}</text>
|
||||
</svg>`;
|
||||
}
|
||||
@@ -0,0 +1,883 @@
|
||||
'use strict';
|
||||
/* global deviceUrl, FACEPLATES, renderFaceplate, faceplateScrollLeft */
|
||||
/* exported renderPortInspector, fmtRate, fmtErrors */
|
||||
|
||||
// Port inspector for a switch or router's device page: front-panel diagram,
|
||||
// port detail panel, switch/server path check, and link diagnostics.
|
||||
|
||||
const escHtml = s => lt.escHtml(s);
|
||||
|
||||
// ── Formatting helpers ───────────────────────────────────────────────────
|
||||
function fmtShortSpeed(mbps) {
|
||||
if (!mbps) return '-';
|
||||
if (mbps >= 1000) return (mbps / 1000).toFixed(0) + 'G';
|
||||
return mbps + 'M';
|
||||
}
|
||||
|
||||
function fmtRate(bytesPerSec) {
|
||||
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';
|
||||
if (bps < 1e9) return (bps / 1e6).toFixed(2) + ' Mbps';
|
||||
return (bps / 1e9).toFixed(3) + ' Gbps';
|
||||
}
|
||||
|
||||
function fmtErrors(rate) {
|
||||
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>`;
|
||||
}
|
||||
|
||||
// ── Build port_idx → port data map ──────────────────────────────────────
|
||||
function buildPortIdxMap(ports) {
|
||||
const map = {};
|
||||
for (const [pname, d] of Object.entries(ports)) {
|
||||
if (d.port_idx != null) {
|
||||
map[d.port_idx] = Object.assign({ name: pname }, d);
|
||||
}
|
||||
}
|
||||
return map;
|
||||
}
|
||||
|
||||
// ── Determine port block CSS state class ────────────────────────────────
|
||||
function portBlockState(d) {
|
||||
if (!d || !d.up) return 'down';
|
||||
if (d.is_uplink) return 'uplink';
|
||||
if (d.poe_power != null && d.poe_power > 0) return 'poe-active';
|
||||
return 'up';
|
||||
}
|
||||
|
||||
// ── Speed label helper ───────────────────────────────────────────────────
|
||||
function portSpeedLabel(port) {
|
||||
if (!port || !port.up) return '';
|
||||
const spd = port.speed_mbps;
|
||||
if (!spd) return '';
|
||||
if (spd >= 10000) return '10G';
|
||||
if (spd >= 1000) return '1G';
|
||||
if (spd >= 100) return '100M';
|
||||
return spd + 'M';
|
||||
}
|
||||
|
||||
// Blocks only fit a few characters of the neighbor, so hover text carries it in full
|
||||
function portTitle(port, idx) {
|
||||
if (!port) return `Port ${idx}`;
|
||||
const neighbor = port.lldp && (port.lldp.system_name || port.lldp.chassis_id);
|
||||
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);
|
||||
const numLabel = sfpBlock ? 'SFP' : idx;
|
||||
const title = portTitle(port, idx);
|
||||
const sfpCls = sfpBlock ? ' sfp-block' : '';
|
||||
const speedTxt = portSpeedLabel(port);
|
||||
// LLDP neighbor: first 6 chars of hostname
|
||||
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 lldpHtml = lldpName ? `<span class="port-lldp">${lldpName}</span>` : '';
|
||||
const speedHtml = speedTxt ? `<span class="port-speed">${speedTxt}</span>` : '';
|
||||
return `<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">${numLabel}</span>${speedHtml}${lldpHtml}</div>`;
|
||||
}
|
||||
|
||||
// ── Chassis legend HTML ──────────────────────────────────────────────────
|
||||
function chassisLegendHtml() {
|
||||
return `<div class="chassis-legend">
|
||||
<div class="chassis-legend-item"><span class="chassis-legend-swatch cls-down"></span>down</div>
|
||||
<div class="chassis-legend-item"><span class="chassis-legend-swatch cls-up"></span>up</div>
|
||||
<div class="chassis-legend-item"><span class="chassis-legend-swatch cls-poe"></span>poe active</div>
|
||||
<div class="chassis-legend-item"><span class="chassis-legend-swatch cls-uplink"></span>uplink</div>
|
||||
</div>`;
|
||||
}
|
||||
|
||||
// ── Render one switch chassis ────────────────────────────────────────────
|
||||
function renderChassis(swName, sw) {
|
||||
const model = sw.model || '';
|
||||
const portMap = buildPortIdxMap(sw.ports || {});
|
||||
const ports = Object.entries(sw.ports || {});
|
||||
|
||||
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>`;
|
||||
|
||||
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>
|
||||
<div class="chassis-rows"><div class="chassis-row">${blocks}</div></div>
|
||||
</div>
|
||||
${chassisLegendHtml()}
|
||||
</div>`;
|
||||
}
|
||||
|
||||
// ── State ────────────────────────────────────────────────────────────────
|
||||
let _selectedSwitch = null;
|
||||
let _selectedIdx = null;
|
||||
let _apiData = null;
|
||||
let _diagPollTimer = null;
|
||||
|
||||
// ── Port selection ───────────────────────────────────────────────────────
|
||||
function selectPort(el) {
|
||||
selectPortByIdx(el.dataset.switch, parseInt(el.dataset.portIdx, 10));
|
||||
}
|
||||
|
||||
function selectPortByIdx(swName, idx) {
|
||||
const sw = _apiData && _apiData.unifi_switches[swName];
|
||||
if (!sw || !buildPortIdxMap(sw.ports || {})[idx]) return;
|
||||
if (_diagPollTimer) { clearInterval(_diagPollTimer); _diagPollTimer = null; }
|
||||
_selectedSwitch = swName;
|
||||
_selectedIdx = idx;
|
||||
renderPanel(swName, idx);
|
||||
highlightSelectedPort();
|
||||
history.replaceState(null, '', `#port-${idx}`);
|
||||
// On narrow screens the panel sits below the front panel, possibly off screen
|
||||
if (window.matchMedia('(max-width: 900px)').matches) {
|
||||
document.getElementById('inspector-panel').scrollIntoView({ behavior: 'smooth', block: 'nearest' });
|
||||
}
|
||||
}
|
||||
|
||||
function closePanel() {
|
||||
if (_diagPollTimer) { clearInterval(_diagPollTimer); _diagPollTimer = null; }
|
||||
document.getElementById('inspector-panel').classList.remove('open');
|
||||
_selectedSwitch = null;
|
||||
_selectedIdx = null;
|
||||
highlightSelectedPort();
|
||||
history.replaceState(null, '', window.location.pathname + window.location.search);
|
||||
}
|
||||
|
||||
// ── Render detail panel ──────────────────────────────────────────────────
|
||||
function renderPanel(swName, idx) {
|
||||
if (!_apiData) return;
|
||||
const sw = _apiData.unifi_switches && _apiData.unifi_switches[swName];
|
||||
if (!sw) return;
|
||||
const portMap = buildPortIdxMap(sw.ports || {});
|
||||
const d = portMap[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 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 autoneg = d.autoneg ? 'On' : 'Off';
|
||||
const mediaStr = d.media || '-';
|
||||
const isUplinkBadge = d.is_uplink ? ' <span class="port-badge port-badge-uplink">UPLINK</span>' : '';
|
||||
|
||||
// PoE section
|
||||
let poeHtml = '';
|
||||
if (d.poe_power || d.poe_max_power) {
|
||||
const poeMaxStr = d.poe_max_power != null ? ` / max ${d.poe_max_power.toFixed(1)}W` : '';
|
||||
poeHtml = `
|
||||
<div class="lt-divider"><span class="lt-divider-label">PoE</span></div>
|
||||
<div class="panel-row"><span class="panel-label">Class</span><span class="panel-val">class ${escHtml(String(d.poe_class))}${poeMaxStr}</span></div>
|
||||
${d.poe_power != null ? `<div class="panel-row"><span class="panel-label">Draw</span><span class="panel-val">${d.poe_power > 0 ? `<span class="val-amber">${d.poe_power.toFixed(1)}W</span>` : '0W'}</span></div>` : ''}
|
||||
${d.poe_mode ? `<div class="panel-row"><span class="panel-label">Mode</span><span class="panel-val">${escHtml(d.poe_mode)}</span></div>` : ''}`;
|
||||
}
|
||||
|
||||
// Traffic section
|
||||
let trafficHtml = '';
|
||||
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>`;
|
||||
}
|
||||
|
||||
// Errors / drops section
|
||||
let errHtml = '';
|
||||
if (d.tx_errs_rate != null || d.rx_errs_rate != null) {
|
||||
errHtml = `
|
||||
<div class="lt-divider"><span class="lt-divider-label">Errors / Drops</span></div>
|
||||
<div class="panel-row"><span class="panel-label">TX Err</span><span class="panel-val">${fmtErrors(d.tx_errs_rate)}</span></div>
|
||||
<div class="panel-row"><span class="panel-label">RX Err</span><span class="panel-val">${fmtErrors(d.rx_errs_rate)}</span></div>
|
||||
<div class="panel-row"><span class="panel-label">TX Drop</span><span class="panel-val">${fmtErrors(d.tx_drops_rate)}</span></div>
|
||||
<div class="panel-row"><span class="panel-label">RX Drop</span><span class="panel-val">${fmtErrors(d.rx_drops_rate)}</span></div>`;
|
||||
}
|
||||
|
||||
// LLDP + path debug
|
||||
let lldpHtml = '';
|
||||
let pathHtml = '';
|
||||
if (d.lldp) {
|
||||
const l = d.lldp;
|
||||
lldpHtml = `
|
||||
<div class="lt-divider"><span class="lt-divider-label">${l.source === 'unifi-clients' ? 'Neighbor (UniFi client table)' : 'LLDP Neighbor'}</span></div>
|
||||
${l.system_name ? `<div class="panel-row"><span class="panel-label">System</span><span class="panel-val val-cyan"><a class="device-link" href="${escHtml(deviceUrl(l.system_name))}">${escHtml(l.system_name)}</a></span></div>` : ''}
|
||||
${l.port_id ? `<div class="panel-row"><span class="panel-label">Port</span><span class="panel-val">${escHtml(l.port_id)}</span></div>` : ''}
|
||||
${l.port_desc ? `<div class="panel-row"><span class="panel-label">Port Desc</span><span class="panel-val">${escHtml(l.port_desc)}</span></div>` : ''}
|
||||
${l.chassis_id ? `<div class="panel-row"><span class="panel-label">Chassis</span><span class="panel-val">${escHtml(l.chassis_id)}</span></div>` : ''}
|
||||
${l.mgmt_ips && l.mgmt_ips.length ? `<div class="panel-row"><span class="panel-label">Mgmt IP</span><span class="panel-val">${escHtml(l.mgmt_ips.join(', '))}</span></div>` : ''}`;
|
||||
|
||||
// Path debug: look for matching server interface
|
||||
const hosts = _apiData.hosts || {};
|
||||
const serverIfaces = hosts[l.system_name];
|
||||
if (serverIfaces) {
|
||||
let matchedIface = l.port_id && serverIfaces[l.port_id] ? l.port_id : null;
|
||||
if (!matchedIface && l.port_id) {
|
||||
// fuzzy match
|
||||
matchedIface = Object.keys(serverIfaces).find(k => l.port_id.includes(k) || k.includes(l.port_id)) || null;
|
||||
}
|
||||
if (matchedIface) {
|
||||
pathHtml = buildPathDebug(swName, d, l.system_name, matchedIface, serverIfaces[matchedIface]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Diagnose button (only when LLDP has an identified neighbor we can map)
|
||||
const hasDiagTarget = !!(d.lldp && d.lldp.system_name &&
|
||||
_apiData.hosts && _apiData.hosts[d.lldp.system_name]);
|
||||
const diagHtml = hasDiagTarget ? `
|
||||
<div class="diag-bar">
|
||||
<button class="btn-diag lt-btn lt-btn-secondary lt-btn-sm" data-action="run-diagnostic"
|
||||
data-sw="${escHtml(swName)}" data-idx="${idx}"
|
||||
aria-label="Run link diagnostics for port ${idx} on ${escHtml(swName)}">Run Diagnostics</button>
|
||||
<span class="diag-status" id="diag-status"></span>
|
||||
</div>
|
||||
<div class="diag-results" id="diag-results"></div>` : '';
|
||||
|
||||
// Auto-refresh re-renders this panel. A running poll holds these elements,
|
||||
// and results may be on screen, so carry them over for the same port.
|
||||
const inner = document.getElementById('inspector-panel-inner');
|
||||
const panelKey = `${swName}#${idx}`;
|
||||
const samePort = inner.dataset.port === panelKey;
|
||||
const keptStatus = samePort ? document.getElementById('diag-status') : null;
|
||||
const keptResults = samePort ? document.getElementById('diag-results') : null;
|
||||
const scrollTop = samePort ? inner.scrollTop : 0;
|
||||
inner.dataset.port = panelKey;
|
||||
inner.innerHTML = `
|
||||
<div class="panel-header">
|
||||
<div>
|
||||
<span class="panel-port-name">${escHtml(d.name)}</span>${isUplinkBadge}
|
||||
<div class="panel-meta">${escHtml(swName)} · port #${idx}</div>
|
||||
</div>
|
||||
<button class="panel-close" data-action="close-panel" aria-label="Close panel">✕</button>
|
||||
</div>
|
||||
|
||||
<div class="lt-divider"><span class="lt-divider-label">Link</span></div>
|
||||
<div class="panel-row"><span class="panel-label">Status</span><span class="panel-val">${upStr}</span></div>
|
||||
<div class="panel-row"><span class="panel-label">Speed</span><span class="panel-val">${speedStr}</span></div>
|
||||
<div class="panel-row"><span class="panel-label" data-tooltip="Full = simultaneous send/receive. Half = one direction at a time.">Duplex</span><span class="panel-val">${duplexStr}</span></div>
|
||||
<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}
|
||||
${lldpHtml}
|
||||
${pathHtml}
|
||||
${diagHtml}
|
||||
`;
|
||||
if (keptStatus) document.getElementById('diag-status')?.replaceWith(keptStatus);
|
||||
if (keptResults) document.getElementById('diag-results')?.replaceWith(keptResults);
|
||||
inner.scrollTop = scrollTop;
|
||||
|
||||
document.getElementById('inspector-panel').classList.add('open');
|
||||
}
|
||||
|
||||
// ── Build path debug two-column section ─────────────────────────────────
|
||||
function buildPathDebug(swName, swPort, serverName, ifaceName, svrData) {
|
||||
const isFiber = (swPort.media || '').toLowerCase().includes('sfp') ||
|
||||
(svrData.port_type || '').toLowerCase().includes('fibre') ||
|
||||
(svrData.port_type || '').toLowerCase().includes('fiber') ||
|
||||
!!svrData.sfp;
|
||||
const connType = isFiber ? 'SFP / Fiber' : 'Copper';
|
||||
|
||||
let sfpDomHtml = '';
|
||||
if (svrData.sfp && Object.keys(svrData.sfp).length) {
|
||||
const sfp = svrData.sfp;
|
||||
sfpDomHtml = '<div class="path-dom">';
|
||||
if (sfp.vendor) sfpDomHtml += `<div class="path-dom-row"><span>Vendor</span><span>${escHtml(sfp.vendor)}${sfp.part_no ? ' / ' + escHtml(sfp.part_no) : ''}</span></div>`;
|
||||
if (sfp.temp_c != null) sfpDomHtml += `<div class="path-dom-row"><span>Temp</span><span>${sfp.temp_c.toFixed(1)}°C</span></div>`;
|
||||
if (sfp.tx_power_dbm != null) sfpDomHtml += `<div class="path-dom-row"><span>TX</span><span>${sfp.tx_power_dbm.toFixed(2)} dBm</span></div>`;
|
||||
if (sfp.rx_power_dbm != null) sfpDomHtml += `<div class="path-dom-row"><span>RX</span><span>${sfp.rx_power_dbm.toFixed(2)} dBm</span></div>`;
|
||||
sfpDomHtml += '</div>';
|
||||
}
|
||||
|
||||
const svrErrTx = (svrData.tx_errs_rate > 0.001) ? 'val-crit' : 'val-good';
|
||||
const svrErrRx = (svrData.rx_errs_rate > 0.001) ? 'val-crit' : 'val-good';
|
||||
const swErrTx = (swPort.tx_errs_rate > 0.001) ? 'val-crit' : 'val-good';
|
||||
const swErrRx = (swPort.rx_errs_rate > 0.001) ? 'val-crit' : 'val-good';
|
||||
|
||||
// Detect duplex mismatch (switch full_duplex vs server duplex string)
|
||||
const swFull = swPort.full_duplex;
|
||||
const svrFull = (svrData.duplex || '').toLowerCase().includes('full');
|
||||
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>`
|
||||
: '';
|
||||
|
||||
// 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>`
|
||||
: '';
|
||||
|
||||
return `
|
||||
<div class="lt-divider"><span class="lt-divider-label">Path Debug · ${escHtml(connType)}</span></div>
|
||||
${duplexWarnHtml}${speedWarnHtml}
|
||||
<div class="path-debug-cols">
|
||||
<div class="path-col">
|
||||
<div class="path-col-header">Switch</div>
|
||||
<div class="path-row"><span>Port</span><span>${escHtml(swPort.name)}</span></div>
|
||||
<div class="path-row"><span>Speed</span><span>${fmtShortSpeed(swPort.speed_mbps)}bps</span></div>
|
||||
<div class="path-row"><span>TX</span><span>${fmtRate(swPort.tx_bytes_rate)}</span></div>
|
||||
<div class="path-row"><span>RX</span><span>${fmtRate(swPort.rx_bytes_rate)}</span></div>
|
||||
<div class="path-row"><span>TX Err</span><span class="${swErrTx}">${fmtErrors(swPort.tx_errs_rate)}</span></div>
|
||||
<div class="path-row"><span>RX Err</span><span class="${swErrRx}">${fmtErrors(swPort.rx_errs_rate)}</span></div>
|
||||
${(swPort.poe_power != null && swPort.poe_power > 0) ? `<div class="path-row"><span>PoE</span><span class="val-amber">${swPort.poe_power.toFixed(1)}W</span></div>` : ''}
|
||||
</div>
|
||||
<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>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>
|
||||
<div class="path-row"><span>RX Err</span><span class="${svrErrRx}">${fmtErrors(svrData.rx_errs_rate)}</span></div>
|
||||
${svrData.carrier_changes != null ? `<div class="path-row"><span>Carrier Chg</span><span class="${(svrData.carrier_changes||0)>10?'val-crit':(svrData.carrier_changes||0)>2?'val-warn':'val-good'}">${svrData.carrier_changes}</span></div>` : ''}
|
||||
${sfpDomHtml}
|
||||
</div>
|
||||
</div>`;
|
||||
}
|
||||
|
||||
// ── 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 || {},
|
||||
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) {
|
||||
openPortFromHash(detail.name);
|
||||
}
|
||||
highlightSelectedPort();
|
||||
}
|
||||
|
||||
function openPortFromHash(swName) {
|
||||
const m = /^#port-(\d+)$/.exec(window.location.hash);
|
||||
if (m) selectPortByIdx(swName, parseInt(m[1], 10));
|
||||
}
|
||||
|
||||
function highlightSelectedPort() {
|
||||
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);
|
||||
});
|
||||
}
|
||||
|
||||
document.addEventListener('keydown', e => {
|
||||
if (e.key === 'Escape' && document.getElementById('inspector-panel').classList.contains('open')) {
|
||||
closePanel();
|
||||
return;
|
||||
}
|
||||
if (e.key !== 'Enter' && e.key !== ' ') return;
|
||||
const block = e.target.closest('[data-action="select-port"]');
|
||||
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; }
|
||||
|
||||
const closeBtn = e.target.closest('[data-action="close-panel"]');
|
||||
if (closeBtn) { closePanel(); return; }
|
||||
|
||||
const diagBtn = e.target.closest('[data-action="run-diagnostic"]');
|
||||
if (diagBtn) { runDiagnostic(diagBtn.dataset.sw, parseInt(diagBtn.dataset.idx, 10)); return; }
|
||||
|
||||
const toggleDiag = e.target.closest('[data-action="toggle-diag"]');
|
||||
if (toggleDiag) {
|
||||
const section = toggleDiag.parentElement;
|
||||
const nowOpen = section.classList.toggle('diag-open');
|
||||
const hint = toggleDiag.querySelector('.diag-toggle-hint');
|
||||
if (hint) hint.textContent = nowOpen ? '[collapse]' : '[expand]';
|
||||
return;
|
||||
}
|
||||
});
|
||||
|
||||
// ── Link Diagnostics ─────────────────────────────────────────────────
|
||||
|
||||
function runDiagnostic(swName, portIdx) {
|
||||
const statusEl = document.getElementById('diag-status');
|
||||
const resultsEl = document.getElementById('diag-results');
|
||||
if (!statusEl || !resultsEl) return;
|
||||
|
||||
// Clear any previous poll
|
||||
if (_diagPollTimer) { clearInterval(_diagPollTimer); _diagPollTimer = null; }
|
||||
|
||||
statusEl.textContent = 'Submitting to Pulse...';
|
||||
resultsEl.innerHTML = '';
|
||||
|
||||
lt.api.post('/api/diagnose', {switch_name: swName, port_idx: portIdx})
|
||||
.then(resp => {
|
||||
statusEl.textContent = 'Collecting diagnostics via Pulse...';
|
||||
pollDiagnostic(resp.job_id, statusEl, resultsEl);
|
||||
})
|
||||
.catch(e => {
|
||||
const msg = (e && e.status === 429)
|
||||
? 'Rate limit reached: max 5 diagnostics per minute. Please wait.'
|
||||
: 'Error: ' + (e && e.message || 'Request failed');
|
||||
statusEl.textContent = msg;
|
||||
});
|
||||
}
|
||||
|
||||
function pollDiagnostic(jobId, statusEl, resultsEl) {
|
||||
let attempts = 0;
|
||||
_diagPollTimer = setInterval(() => {
|
||||
attempts++;
|
||||
if (attempts > 120) { // 2min timeout
|
||||
clearInterval(_diagPollTimer);
|
||||
_diagPollTimer = null;
|
||||
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('[data-action="select-port"].selected');
|
||||
if (sel) runDiagnostic(sel.dataset.switch, parseInt(sel.dataset.portIdx));
|
||||
});
|
||||
return;
|
||||
}
|
||||
lt.api.get(`/api/diagnose/${jobId}`)
|
||||
.then(resp => {
|
||||
if (resp.status === 'done') {
|
||||
clearInterval(_diagPollTimer);
|
||||
_diagPollTimer = null;
|
||||
statusEl.textContent = '';
|
||||
renderDiagnosticResults(resp.result, resultsEl);
|
||||
}
|
||||
})
|
||||
.catch(() => {
|
||||
clearInterval(_diagPollTimer);
|
||||
_diagPollTimer = null;
|
||||
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('[data-action="select-port"].selected');
|
||||
if (sel) runDiagnostic(sel.dataset.switch, parseInt(sel.dataset.portIdx));
|
||||
});
|
||||
});
|
||||
}, 2000);
|
||||
}
|
||||
|
||||
function renderDiagnosticResults(d, container) {
|
||||
if (!d || d.status === 'error') {
|
||||
container.innerHTML = `<div class="diag-error">Diagnostic error: ${escHtml((d && d.error) || 'unknown')}</div>`;
|
||||
return;
|
||||
}
|
||||
|
||||
const health = d.health || {};
|
||||
const issues = health.issues || [];
|
||||
const warns = health.warnings || [];
|
||||
const infoArr = health.info || [];
|
||||
const secs = d.sections || {};
|
||||
const eth = secs.ethtool || {};
|
||||
const drv = secs.ethtool_driver || {};
|
||||
const pause = secs.ethtool_pause || {};
|
||||
const ring = secs.ethtool_ring || {};
|
||||
const dom = secs.ethtool_dom || {};
|
||||
const sysfs = secs.sysfs_stats || {};
|
||||
const dmesg = secs.dmesg || [];
|
||||
const lldpctl = secs.lldpctl || {};
|
||||
const nicStats = secs.ethtool_stats || {};
|
||||
const swPort = d.switch_port || {};
|
||||
|
||||
// ── Health banner ──
|
||||
let bannerHtml = '';
|
||||
if (issues.length === 0 && warns.length === 0) {
|
||||
bannerHtml = '<div class="diag-health-banner"><span class="diag-health-ok">ALL OK</span></div>';
|
||||
} else {
|
||||
const parts = [];
|
||||
if (issues.length) parts.push(`<span class="diag-health-critical">${issues.length} CRITICAL</span>`);
|
||||
if (warns.length) parts.push(`<span class="diag-health-warning">${warns.length} WARNING</span>`);
|
||||
bannerHtml = `<div class="diag-health-banner">${parts.join(' ')}</div>`;
|
||||
}
|
||||
|
||||
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>`;
|
||||
}).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>' : '-';
|
||||
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 duplexVal = eth.duplex === 'full' ? '<span class="diag-val-good">Full</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>' : '-';
|
||||
const autonegVal = eth.auto_neg === true ? '<span class="diag-val-good">On</span>' :
|
||||
eth.auto_neg === false ? '<span class="diag-val-warn">Off</span>' : '-';
|
||||
|
||||
const physHtml = `
|
||||
<div class="diag-section">
|
||||
<div class="diag-section-header">Physical Layer</div>
|
||||
<table class="diag-table">
|
||||
<tr><td>Carrier</td><td>${carrierVal}</td></tr>
|
||||
<tr><td>Oper State</td><td><span class="${opstateCls}">${escHtml(operstateVal)}</span></td></tr>
|
||||
<tr><td>Speed</td><td>${speedVal}</td></tr>
|
||||
<tr><td>Duplex</td><td>${duplexVal}</td></tr>
|
||||
<tr><td>Link Detected</td><td>${linkDetVal}</td></tr>
|
||||
<tr><td>Auto-neg</td><td>${autonegVal}</td></tr>
|
||||
${secs.carrier_changes != null ? `<tr><td>Carrier Changes</td><td><span class="${secs.carrier_changes > 20 ? 'diag-val-warn' : 'diag-val-good'}">${secs.carrier_changes}</span></td></tr>` : ''}
|
||||
</table>
|
||||
</div>`;
|
||||
|
||||
// ── SFP / DOM ──
|
||||
let domHtml = '';
|
||||
if (dom && Object.keys(dom).length > 0) {
|
||||
const rxBar = dom.rx_power_dbm != null ? renderPowerBar(dom.rx_power_dbm, -18, -25) : '';
|
||||
const txBar = dom.tx_power_dbm != null ? renderPowerBar(dom.tx_power_dbm, -10, -13) : '';
|
||||
domHtml = `
|
||||
<div class="diag-section">
|
||||
<div class="diag-section-header">SFP / DOM</div>
|
||||
<table class="diag-table">
|
||||
${dom.vendor ? `<tr><td>Vendor</td><td>${escHtml(dom.vendor)}${dom.part_no ? ' / ' + escHtml(dom.part_no) : ''}</td></tr>` : ''}
|
||||
${dom.sfp_type ? `<tr><td>Type</td><td>${escHtml(dom.sfp_type)}</td></tr>` : ''}
|
||||
${dom.connector ? `<tr><td>Connector</td><td>${escHtml(dom.connector)}</td></tr>` : ''}
|
||||
${dom.wavelength_nm != null ? `<tr><td>Wavelength</td><td>${dom.wavelength_nm} nm</td></tr>` : ''}
|
||||
${dom.temp_c != null ? `<tr><td>Temperature</td><td>${dom.temp_c.toFixed(1)} °C</td></tr>` : ''}
|
||||
${dom.voltage_v != null ? `<tr><td>Voltage</td><td>${dom.voltage_v.toFixed(4)} V</td></tr>` : ''}
|
||||
${dom.bias_ma != null ? `<tr><td>Bias Current</td><td>${dom.bias_ma.toFixed(3)} mA</td></tr>` : ''}
|
||||
${dom.tx_power_dbm != null ? `<tr><td>TX Power</td><td>${dom.tx_power_dbm.toFixed(2)} dBm ${txBar}</td></tr>` : ''}
|
||||
${dom.rx_power_dbm != null ? `<tr><td>RX Power</td><td>${dom.rx_power_dbm.toFixed(2)} dBm ${rxBar}</td></tr>` : ''}
|
||||
</table>
|
||||
</div>`;
|
||||
}
|
||||
|
||||
// ── NIC Error Counters ──
|
||||
const errCounters = ['rx_crc_errors','rx_frame_errors','collisions','tx_carrier_errors','rx_missed_errors','rx_fifo_errors'];
|
||||
const nonZeroCounters = errCounters.filter(k => sysfs[k] > 0);
|
||||
let errCounterHtml = '';
|
||||
if (nonZeroCounters.length > 0 || secs.carrier_changes > 0) {
|
||||
const rows = nonZeroCounters.map(k => {
|
||||
const v = sysfs[k];
|
||||
const cls = v > 100 ? 'diag-val-bad' : 'diag-val-warn';
|
||||
return `<tr><td>${escHtml(k)}</td><td class="${cls}">${v.toLocaleString()}</td></tr>`;
|
||||
}).join('');
|
||||
errCounterHtml = `
|
||||
<div class="diag-section">
|
||||
<div class="diag-section-header">NIC Error Counters</div>
|
||||
<table class="diag-table">
|
||||
${rows || '<tr><td colspan="2" class="diag-val-good">All zero</td></tr>'}
|
||||
</table>
|
||||
</div>`;
|
||||
}
|
||||
|
||||
// ── ethtool -S (collapsible) ──
|
||||
let nicStatHtml = '';
|
||||
if (Object.keys(nicStats).length > 0) {
|
||||
const _ERR_KEYS = /err|drop|miss|crc|frame|fifo|abort|carrier|collision|fault|discard|overflow|reset/i;
|
||||
const rows = Object.entries(nicStats).map(([k, v]) => {
|
||||
const cls = _ERR_KEYS.test(k) && v > 0 ? ' class="diag-stat-nonzero-warn"' : '';
|
||||
return `<tr${cls}><td>${escHtml(k)}</td><td>${v.toLocaleString()}</td></tr>`;
|
||||
}).join('');
|
||||
nicStatHtml = `
|
||||
<div class="diag-section diag-collapsible">
|
||||
<div class="diag-section-header diag-toggle" data-action="toggle-diag">
|
||||
ethtool -S (NIC stats) <span class="diag-toggle-hint">[expand]</span>
|
||||
</div>
|
||||
<div class="diag-section-body">
|
||||
<table class="diag-stat-table">${rows}</table>
|
||||
</div>
|
||||
</div>`;
|
||||
}
|
||||
|
||||
// ── Flow Control + Ring Buffers ──
|
||||
let flowRingHtml = '';
|
||||
const hasPause = Object.keys(pause).length > 0;
|
||||
const hasRing = Object.keys(ring).length > 0;
|
||||
if (hasPause || hasRing) {
|
||||
flowRingHtml = `
|
||||
<div class="diag-section">
|
||||
<div class="diag-section-header">Flow Control & Ring Buffers</div>
|
||||
<table class="diag-table">
|
||||
${hasPause ? `
|
||||
<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>` : ''}
|
||||
</table>
|
||||
</div>`;
|
||||
}
|
||||
|
||||
// ── Driver Info ──
|
||||
let drvHtml = '';
|
||||
if (Object.keys(drv).length > 0) {
|
||||
drvHtml = `
|
||||
<div class="diag-section">
|
||||
<div class="diag-section-header">Driver Info</div>
|
||||
<table class="diag-table">
|
||||
${drv.driver ? `<tr><td>Driver</td><td>${escHtml(drv.driver)}</td></tr>` : ''}
|
||||
${drv.version ? `<tr><td>Version</td><td>${escHtml(drv.version)}</td></tr>` : ''}
|
||||
${drv.firmware_version ? `<tr><td>Firmware</td><td>${escHtml(drv.firmware_version)}</td></tr>` : ''}
|
||||
${drv.bus_info ? `<tr><td>Bus</td><td>${escHtml(drv.bus_info)}</td></tr>` : ''}
|
||||
</table>
|
||||
</div>`;
|
||||
}
|
||||
|
||||
// ── LLDP Validation ──
|
||||
let lldpValHtml = '';
|
||||
const swLldp = swPort.lldp || {};
|
||||
lldpValHtml = `
|
||||
<div class="diag-section">
|
||||
<div class="diag-section-header">LLDP Validation</div>
|
||||
<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>
|
||||
<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 class="diag-val-warn">lldpd not running</span></div>'}
|
||||
</div>
|
||||
</div>
|
||||
</div>`;
|
||||
|
||||
// ── dmesg ──
|
||||
let dmesgHtml = '';
|
||||
if (dmesg.length > 0) {
|
||||
const dlines = dmesg.map(e => {
|
||||
const cls = e.severity === 'error' ? ' diag-dmesg-err' : e.severity === 'warn' ? ' diag-dmesg-warn' : '';
|
||||
const ts = e.timestamp ? `[${e.timestamp}] ` : '';
|
||||
return `<div class="diag-dmesg-line${cls}">${escHtml(ts + e.msg)}</div>`;
|
||||
}).join('');
|
||||
dmesgHtml = `
|
||||
<div class="diag-section diag-collapsible">
|
||||
<div class="diag-section-header diag-toggle" data-action="toggle-diag">
|
||||
Kernel Events (dmesg) <span class="diag-toggle-hint">[expand]</span>
|
||||
</div>
|
||||
<div class="diag-section-body">
|
||||
<div class="diag-dmesg-wrap">${dlines}</div>
|
||||
</div>
|
||||
</div>`;
|
||||
}
|
||||
|
||||
// ── Switch Port Summary ──
|
||||
const swSummaryHtml = `
|
||||
<div class="diag-section">
|
||||
<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>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>` : ''}
|
||||
</table>
|
||||
</div>`;
|
||||
|
||||
// ── Pulse link ──
|
||||
const pulseLink = d.pulse_url
|
||||
? `<div class="diag-pulse-link"><a href="${escHtml(d.pulse_url)}" target="_blank" rel="noopener">View raw output in Pulse ↗</a></div>`
|
||||
: '';
|
||||
|
||||
container.innerHTML = `
|
||||
<div class="diag-results-inner">
|
||||
${bannerHtml}
|
||||
<div class="diag-issue-list">${issueRows}</div>
|
||||
${physHtml}
|
||||
${domHtml}
|
||||
${errCounterHtml}
|
||||
${nicStatHtml}
|
||||
${flowRingHtml}
|
||||
${drvHtml}
|
||||
${lldpValHtml}
|
||||
${dmesgHtml}
|
||||
${swSummaryHtml}
|
||||
${pulseLink}
|
||||
</div>`;
|
||||
}
|
||||
|
||||
// SFP power bar: range is 0 dBm (best) to -35 dBm (worst)
|
||||
function renderPowerBar(dbm, warnThreshold, critThreshold) {
|
||||
const minDbm = -35, maxDbm = 0;
|
||||
const pct = Math.max(0, Math.min(100, ((dbm - minDbm) / (maxDbm - minDbm)) * 100));
|
||||
const warnPct = ((warnThreshold - minDbm) / (maxDbm - minDbm)) * 100;
|
||||
const critPct = ((critThreshold - minDbm) / (maxDbm - minDbm)) * 100;
|
||||
const barCls = dbm < critThreshold ? 'diag-val-bad' : dbm < warnThreshold ? 'diag-val-warn' : 'diag-val-good';
|
||||
return `<span class="diag-power-bar-wrap">
|
||||
<span class="diag-power-bar ${barCls}" style="width:${pct.toFixed(1)}%"></span>
|
||||
<span class="diag-power-zone-warn" style="left:${warnPct.toFixed(1)}%"></span>
|
||||
<span class="diag-power-zone-crit" style="left:${critPct.toFixed(1)}%"></span>
|
||||
</span>`;
|
||||
}
|
||||
@@ -0,0 +1,586 @@
|
||||
'use strict';
|
||||
/* global FACEPLATES, renderFaceplate, faceplateSvg, RACK_CAN_EDIT, RACK_FRONTS, CHASSIS_FACEPLATES, rackFrontSvg, shelfSvg */
|
||||
// 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>` : '';
|
||||
}
|
||||
|
||||
// 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>`;
|
||||
}
|
||||
|
||||
// Live faceplates for UniFi desk gear sitting on a shelf (a Flex Mini on top of the NVR)
|
||||
const shelfFaceplates = {
|
||||
spec: model => FACEPLATES[model],
|
||||
svg: (c, attrs) => faceplateSvg(c.model, {
|
||||
swName: c.device || c.name, portMap: portMapOf(c.ports), outlets: [], online: c.status === 'up',
|
||||
titleFor: (port, idx) => portTitle(port, idx),
|
||||
}, attrs).svg,
|
||||
};
|
||||
|
||||
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 = shelfSvg(item, esc, shelfFaceplates);
|
||||
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('');
|
||||
const VIEW_TITLE = { front: 'front', behind: 'rear posts, from the front', rear: 'rear' };
|
||||
document.getElementById('rack-title').textContent = `${data.rack} · ${VIEW_TITLE[data.face] || 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 r = data.racks.find(x => x.name === data.rack) || {};
|
||||
document.querySelector('.rack-face-btn[data-face="behind"]').textContent = r.behind ? `Rear posts (${r.behind})` : 'Rear posts';
|
||||
document.querySelector('.rack-face-btn[data-face="rear"]').textContent = r.rear ? `Rear (${r.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() {
|
||||
const face = new URLSearchParams(location.search).get('face');
|
||||
return ['behind', 'rear'].includes(face) ? face : '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 === 'front' ? '' : btn.dataset.face });
|
||||
});
|
||||
|
||||
async function load() {
|
||||
try {
|
||||
const q = new URLSearchParams();
|
||||
if (currentRack()) q.set('rack', currentRack());
|
||||
if (currentFace() !== 'front') q.set('face', currentFace());
|
||||
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);
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
<section class="g-section" id="modem-section" hidden>
|
||||
<div class="g-section-header">
|
||||
<h2 class="g-section-title">WAN / Fiber</h2>
|
||||
<span class="g-section-actions modem-actions">
|
||||
{% if user.groups and 'admin' in user.groups %}
|
||||
<button type="button" class="lt-btn lt-btn-ghost lt-btn-sm" id="modem-restart-btn" hidden
|
||||
title="Silence alerts (Gandalf and Uptime Kuma), then restart the modem">⟳ Restart modem</button>
|
||||
{% endif %}
|
||||
<a class="lt-btn lt-btn-ghost lt-btn-sm" id="modem-device-link" hidden>↗ Details</a>
|
||||
</span>
|
||||
</div>
|
||||
<div class="lt-frame">
|
||||
<span class="lt-frame-bl">╚</span>
|
||||
<span class="lt-frame-br">╝</span>
|
||||
<div class="lt-section-header" id="modem-title">AT&T Gateway</div>
|
||||
<div id="modem-body" aria-live="polite"></div>
|
||||
</div>
|
||||
</section>
|
||||
@@ -0,0 +1,611 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="en" data-theme="dark">
|
||||
<head>
|
||||
<meta charset="UTF-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0, viewport-fit=cover">
|
||||
<meta name="theme-color" content="#030508">
|
||||
<meta name="robots" content="noindex, nofollow">
|
||||
<meta name="description" content="GANDALF: Global Advanced Network Detection And Link Facilitator">
|
||||
<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 %}Network Monitor{% endblock %} | GANDALF</title>
|
||||
|
||||
<link rel="preconnect" href="https://fonts.googleapis.com">
|
||||
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
|
||||
<link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:ital,wght@0,400;0,600;0,700;1,400&family=VT323&display=swap" rel="stylesheet">
|
||||
|
||||
<link rel="stylesheet" href="{{ url_for('static', filename='base.css') }}">
|
||||
<link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
|
||||
|
||||
<!-- base.js loaded in head so lt.* is available for inline scripts -->
|
||||
<script src="{{ url_for('static', filename='base.js') }}"></script>
|
||||
</head>
|
||||
<body>
|
||||
|
||||
<a class="lt-skip-link" href="#main-content">Skip to main content</a>
|
||||
|
||||
<!-- BOOT OVERLAY -->
|
||||
<div id="lt-boot" class="lt-boot-overlay" data-app-name="GANDALF" style="display:none" aria-hidden="true">
|
||||
<pre id="lt-boot-text" class="lt-boot-text"></pre>
|
||||
</div>
|
||||
|
||||
<!-- MOBILE NAV DRAWER -->
|
||||
<div id="lt-nav-drawer" class="lt-nav-drawer" aria-hidden="true" role="dialog" aria-modal="true" aria-label="Navigation menu">
|
||||
<div class="lt-nav-drawer-header">
|
||||
<span class="lt-brand-title" title="Global Advanced Network Detection And Link Facilitator">GANDALF</span>
|
||||
<button type="button" class="lt-nav-drawer-close" id="lt-nav-drawer-close" aria-label="Close navigation">✕</button>
|
||||
</div>
|
||||
<nav class="lt-nav-drawer-links" aria-label="Mobile navigation">
|
||||
<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('topology_page') }}"
|
||||
class="lt-nav-drawer-link{% if request.endpoint == 'topology_page' %} active{% endif %}"
|
||||
{% if request.endpoint == 'topology_page' %}aria-current="page"{% endif %}>Topology</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>
|
||||
<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>
|
||||
<span class="g-drawer-group">More</span>
|
||||
<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 %}>Alert history</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 %}"
|
||||
{% if request.endpoint == 'suppressions_page' %}aria-current="page"{% endif %}>Suppressions</a>
|
||||
{% if not maintenance %}
|
||||
<button type="button" class="lt-nav-drawer-link g-drawer-action" data-action="start-maintenance">Start maintenance</button>
|
||||
{% endif %}
|
||||
{% endif %}
|
||||
</nav>
|
||||
</div>
|
||||
<div id="lt-nav-overlay" class="lt-nav-drawer-overlay"></div>
|
||||
|
||||
<!-- PRIMARY HEADER -->
|
||||
<header class="lt-header" role="banner">
|
||||
<div class="lt-header-left">
|
||||
|
||||
<!-- Hamburger (mobile) -->
|
||||
<button type="button"
|
||||
class="lt-menu-btn"
|
||||
id="lt-menu-btn"
|
||||
data-action="open-nav-drawer"
|
||||
aria-label="Open navigation menu"
|
||||
aria-expanded="false"
|
||||
aria-controls="lt-nav-drawer">
|
||||
<span class="lt-menu-btn-bar"></span>
|
||||
<span class="lt-menu-btn-bar"></span>
|
||||
<span class="lt-menu-btn-bar"></span>
|
||||
</button>
|
||||
|
||||
<!-- Brand -->
|
||||
<div class="lt-brand">
|
||||
<a href="{{ url_for('index') }}"
|
||||
class="lt-brand-title lt-glitch"
|
||||
data-text="GANDALF"
|
||||
aria-label="GANDALF home">GANDALF</a>
|
||||
<span class="lt-brand-subtitle g-brand-expansion" title="GANDALF: Global Advanced Network Detection And Link Facilitator"><b>G</b>lobal <b>A</b>dvanced <b>N</b>etwork<br><b>D</b>etection <b>A</b>nd <b>L</b>ink <b>F</b>acilitator</span>
|
||||
</div>
|
||||
|
||||
<!-- Desktop nav: the four pages used daily, the rest under More -->
|
||||
<nav class="lt-nav" aria-label="Main navigation">
|
||||
<a href="{{ url_for('index') }}"
|
||||
class="lt-nav-link{% if request.endpoint == 'index' %} active{% endif %}"
|
||||
{% if request.endpoint == 'index' %}aria-current="page"{% endif %}>Dashboard</a>
|
||||
<a href="{{ url_for('topology_page') }}"
|
||||
class="lt-nav-link{% if request.endpoint == 'topology_page' %} active{% endif %}"
|
||||
{% if request.endpoint == 'topology_page' %}aria-current="page"{% endif %}>Topology</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>
|
||||
<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>
|
||||
{% set _more = request.endpoint in ('events_page', 'suppressions_page') %}
|
||||
<details class="g-nav-more">
|
||||
<summary class="lt-nav-link{% if _more %} active{% endif %}">More ▾</summary>
|
||||
<div class="g-nav-more-menu">
|
||||
<a href="{{ url_for('events_page') }}"
|
||||
class="g-nav-more-link{% if request.endpoint == 'events_page' %} active{% endif %}"
|
||||
{% if request.endpoint == 'events_page' %}aria-current="page"{% endif %}>Alert history</a>
|
||||
{% if user.groups and 'admin' in user.groups %}
|
||||
<a href="{{ url_for('suppressions_page') }}"
|
||||
class="g-nav-more-link{% if request.endpoint == 'suppressions_page' %} active{% endif %}"
|
||||
{% if request.endpoint == 'suppressions_page' %}aria-current="page"{% endif %}>Suppressions</a>
|
||||
{% endif %}
|
||||
</div>
|
||||
</details>
|
||||
</nav>
|
||||
</div>
|
||||
|
||||
<div class="lt-header-right">
|
||||
{% set _uname = user.name or user.username %}
|
||||
{% set _words = _uname.split() %}
|
||||
{% set _initials = (_words[0][0] ~ (_words[1][0] if _words|length > 1 else ''))|upper %}
|
||||
<div class="lt-avatar lt-avatar--sm {{ _uname | avatar_color }}"
|
||||
aria-hidden="true" title="{{ _uname }}">
|
||||
<img src="{{ url_for('api_avatar') }}" alt="" class="lt-avatar-img">
|
||||
<span class="lt-avatar-initials">{{ _initials }}</span>
|
||||
</div>
|
||||
<span class="lt-header-user">{{ _uname }}</span>
|
||||
{% if user.groups and 'admin' in user.groups %}
|
||||
<span class="lt-badge lt-badge-admin" aria-label="Administrator">ADMIN</span>
|
||||
{% if not maintenance %}
|
||||
<button type="button" class="lt-btn lt-btn-ghost lt-btn-sm" data-action="start-maintenance"
|
||||
title="Pause all tickets while you work on the network">Maintenance</button>
|
||||
{% endif %}
|
||||
{% endif %}
|
||||
|
||||
<!-- 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"
|
||||
id="lt-notif-bell"
|
||||
aria-label="Active alerts"
|
||||
aria-expanded="false"
|
||||
aria-controls="lt-notif-panel"
|
||||
title="Active alerts">🔔</button>
|
||||
<div class="lt-notif-panel" id="lt-notif-panel" aria-hidden="true" role="dialog" aria-label="Active alerts">
|
||||
<div class="lt-notif-panel-header">
|
||||
<span>Active Alerts</span>
|
||||
<button type="button" class="lt-notif-panel-clear" id="lt-notif-clear-btn">Mark all read</button>
|
||||
</div>
|
||||
<div class="lt-notif-panel-list" id="lt-notif-list">
|
||||
<div class="lt-notif-empty">Loading…</div>
|
||||
</div>
|
||||
<div class="lt-notif-panel-footer">
|
||||
<a href="{{ url_for('index') }}" class="lt-btn lt-btn-ghost lt-btn-sm lt-notif-view-all">View dashboard</a>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- ⌘K affordance -->
|
||||
<button type="button"
|
||||
class="lt-btn lt-btn-ghost lt-btn-sm lt-cmd-hint-btn"
|
||||
data-action="open-cmdpalette"
|
||||
title="Command palette (Ctrl+K)"
|
||||
aria-label="Open command palette">⌕ K</button>
|
||||
|
||||
<button type="button" class="lt-theme-btn" id="lt-theme-btn"
|
||||
aria-label="Toggle theme" title="Toggle light/dark mode">☀</button>
|
||||
</div>
|
||||
</header>
|
||||
|
||||
<!-- COMMAND PALETTE -->
|
||||
<div id="lt-cmd-overlay" class="lt-cmd-overlay" role="dialog" aria-modal="true" aria-label="Command palette" aria-hidden="true">
|
||||
<div class="lt-cmd-palette" id="lt-cmd-palette">
|
||||
<div class="lt-cmd-input-wrap">
|
||||
<span class="lt-cmd-prompt">></span>
|
||||
<input id="lt-cmd-input" class="lt-cmd-input" type="text"
|
||||
placeholder="Search commands…" autocomplete="off"
|
||||
spellcheck="false" aria-label="Search commands">
|
||||
</div>
|
||||
<div class="lt-cmd-results" id="lt-cmd-results">
|
||||
<div class="lt-cmd-empty">Start typing to search…</div>
|
||||
</div>
|
||||
<div class="lt-cmd-footer">
|
||||
<span><kbd>↑</kbd><kbd>↓</kbd> Navigate</span>
|
||||
<span><kbd>Enter</kbd> Select</span>
|
||||
<span><kbd>Esc</kbd> Close</span>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- MAIN CONTENT -->
|
||||
<main class="lt-main lt-container" id="main-content">
|
||||
{% if maintenance %}
|
||||
<div class="maint-banner" role="status">
|
||||
<span class="maint-banner-text">
|
||||
<strong>Maintenance:</strong> Gandalf is not opening tickets
|
||||
{% if maintenance.expires_at %}until <time class="maint-until" datetime="{{ maintenance.expires_at }}">{{ maintenance.expires_at }}</time>{% else %}until it is ended{% endif %}.
|
||||
Alerts are still recorded, and anything still failing afterwards gets a ticket.
|
||||
<span class="maint-reason">{{ maintenance.reason }}{% if maintenance.suppressed_by %} ({{ maintenance.suppressed_by }}){% endif %}</span>
|
||||
</span>
|
||||
{% if user.groups and 'admin' in user.groups %}
|
||||
<button type="button" class="lt-btn lt-btn-secondary lt-btn-sm" data-action="end-maintenance"
|
||||
data-sup-id="{{ maintenance.id }}">End now</button>
|
||||
{% endif %}
|
||||
</div>
|
||||
{% endif %}
|
||||
{% block content %}{% endblock %}
|
||||
</main>
|
||||
|
||||
<!-- FOOTER: context-sensitive per page -->
|
||||
<footer class="lt-footer" role="contentinfo">
|
||||
<nav class="lt-footer-hints" aria-label="Keyboard shortcuts">
|
||||
{% if request.endpoint == 'index' %}
|
||||
<span class="lt-footer-hint"><span class="lt-footer-key">[ R ]</span> REFRESH</span>
|
||||
<span class="lt-footer-sep">|</span>
|
||||
<span class="lt-footer-hint"><span class="lt-footer-key">[ S ]</span> SUPPRESS</span>
|
||||
<span class="lt-footer-sep">|</span>
|
||||
{% elif request.endpoint == 'device_page' %}
|
||||
<span class="lt-footer-hint"><span class="lt-footer-key">[ R ]</span> REFRESH</span>
|
||||
<span class="lt-footer-sep">|</span>
|
||||
{% endif %}
|
||||
<button type="button" class="lt-footer-hint" data-action="open-settings"><span class="lt-footer-key">[ * ]</span> CFG</button>
|
||||
<span class="lt-footer-sep">|</span>
|
||||
<button type="button" class="lt-footer-hint" data-action="show-keyboard-help"><span class="lt-footer-key">[ ? ]</span> HELP</button>
|
||||
</nav>
|
||||
<span>GANDALF: Global Advanced Network Detection And Link Facilitator | TDS v1.2</span>
|
||||
</footer>
|
||||
|
||||
{% if user.groups and 'admin' in user.groups and not maintenance %}
|
||||
<!-- MAINTENANCE MODAL: pause every ticket for a while -->
|
||||
<div id="maint-modal" class="lt-modal-overlay"
|
||||
role="dialog" aria-modal="true" aria-labelledby="maint-modal-title" aria-hidden="true">
|
||||
<div class="lt-modal">
|
||||
<div class="lt-modal-header">
|
||||
<h3 class="lt-modal-title" id="maint-modal-title">Start maintenance</h3>
|
||||
<button type="button" class="lt-modal-close" data-modal-close aria-label="Close">✕</button>
|
||||
</div>
|
||||
<form id="maint-form">
|
||||
<div class="lt-modal-body">
|
||||
<p class="lt-field-hint maint-intro">Gandalf keeps checking and recording alerts but opens no tickets
|
||||
until this ends. Anything still failing afterwards gets a ticket as usual.</p>
|
||||
<div class="lt-form-group">
|
||||
<label class="lt-label" for="maint-reason">Reason <span class="required">*</span></label>
|
||||
<input type="text" class="lt-input" id="maint-reason" name="reason" maxlength="500"
|
||||
value="Maintenance" required aria-required="true"
|
||||
placeholder="e.g. UniFi Network update">
|
||||
</div>
|
||||
<div class="lt-form-group lt-form-group--last">
|
||||
<span class="lt-label" id="maint-len-label">How long</span>
|
||||
<div class="duration-pills" role="group" aria-labelledby="maint-len-label">
|
||||
<button type="button" class="maint-pill" data-minutes="30" aria-pressed="false">30 min</button>
|
||||
<button type="button" class="maint-pill active" data-minutes="60" aria-pressed="true">1 hr</button>
|
||||
<button type="button" class="maint-pill" data-minutes="120" aria-pressed="false">2 hr</button>
|
||||
<button type="button" class="maint-pill" data-minutes="240" aria-pressed="false">4 hr</button>
|
||||
</div>
|
||||
</div>
|
||||
</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">Start</button>
|
||||
</div>
|
||||
</form>
|
||||
</div>
|
||||
</div>
|
||||
{% endif %}
|
||||
|
||||
<!-- 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">
|
||||
<div class="lt-modal-header">
|
||||
<h3 class="lt-modal-title" id="suppress-modal-title">Suppress Alert</h3>
|
||||
<button type="button" class="lt-modal-close" data-modal-close aria-label="Close">✕</button>
|
||||
</div>
|
||||
<form id="suppress-form">
|
||||
<div class="lt-modal-body">
|
||||
<div class="lt-form-group">
|
||||
<label class="lt-label" for="sup-type">Target Type</label>
|
||||
<select class="lt-select" id="sup-type" name="target_type">
|
||||
<option value="host">Host (all interfaces)</option>
|
||||
<option value="interface">Specific Interface</option>
|
||||
<option value="unifi_device">UniFi Device</option>
|
||||
<option value="all">Global Maintenance</option>
|
||||
</select>
|
||||
</div>
|
||||
<div class="lt-form-group" id="sup-name-group">
|
||||
<label class="lt-label" for="sup-name">Target Name</label>
|
||||
<input type="text" class="lt-input" id="sup-name" name="target_name" placeholder="e.g. compute-storage-02">
|
||||
</div>
|
||||
<div class="lt-form-group" id="sup-detail-group" style="display:none">
|
||||
<label class="lt-label" for="sup-detail">Interface <span class="lt-field-hint">(interface type only)</span></label>
|
||||
<input type="text" class="lt-input" id="sup-detail" name="target_detail" placeholder="e.g. enp35s0">
|
||||
</div>
|
||||
<div class="lt-form-group">
|
||||
<label class="lt-label" for="sup-reason">Reason <span class="required">*</span></label>
|
||||
<input type="text" class="lt-input" id="sup-reason" name="reason"
|
||||
placeholder="e.g. Planned switch reboot" required aria-required="true">
|
||||
</div>
|
||||
<div class="lt-form-group lt-form-group--last">
|
||||
<label class="lt-label">Duration</label>
|
||||
<div class="duration-pills" role="group" aria-label="Select suppression duration">
|
||||
<button type="button" class="pill" data-duration="30" aria-pressed="false" aria-label="30 minutes">30 min</button>
|
||||
<button type="button" class="pill" data-duration="60" aria-pressed="false" aria-label="1 hour">1 hr</button>
|
||||
<button type="button" class="pill" data-duration="240" aria-pressed="false" aria-label="4 hours">4 hr</button>
|
||||
<button type="button" class="pill" data-duration="480" aria-pressed="false" aria-label="8 hours">8 hr</button>
|
||||
<button type="button" class="pill pill-manual active" data-duration="" aria-pressed="true" aria-label="Manual, no expiry">Manual ∞</button>
|
||||
</div>
|
||||
<input type="hidden" id="sup-expires" name="expires_minutes" value="">
|
||||
<div class="lt-field-hint" id="duration-hint">Persists until manually removed.</div>
|
||||
</div>
|
||||
</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">Apply</button>
|
||||
</div>
|
||||
</form>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- KEYBOARD SHORTCUTS MODAL -->
|
||||
<div id="lt-keys-help" class="lt-modal-overlay" aria-hidden="true">
|
||||
<div class="lt-modal" role="dialog" aria-modal="true" aria-labelledby="keys-help-title">
|
||||
<div class="lt-modal-header">
|
||||
<span class="lt-modal-title" id="keys-help-title">Keyboard Shortcuts</span>
|
||||
<button type="button" class="lt-modal-close" data-modal-close aria-label="Close">✕</button>
|
||||
</div>
|
||||
<div class="lt-modal-body">
|
||||
<p class="g-help-about"><strong>GANDALF</strong>: <b>G</b>lobal <b>A</b>dvanced <b>N</b>etwork <b>D</b>etection <b>A</b>nd <b>L</b>ink <b>F</b>acilitator. It watches the UniFi switches and the hosts' links, works out what is plugged in where, and raises a ticket when something breaks.</p>
|
||||
<table class="lt-table">
|
||||
<thead><tr><th>Shortcut</th><th>Action</th></tr></thead>
|
||||
<tbody>
|
||||
<tr><td>Ctrl / ⌘ + K</td><td>Command palette</td></tr>
|
||||
<tr><td>R</td><td>Refresh data (Dashboard / Device)</td></tr>
|
||||
<tr><td>/</td><td>Search devices (Dashboard)</td></tr>
|
||||
<tr><td>S</td><td>Quick-suppress alert (Dashboard)</td></tr>
|
||||
<tr><td>*</td><td>Open settings</td></tr>
|
||||
<tr><td>?</td><td>Show this help</td></tr>
|
||||
<tr><td>ESC</td><td>Close modal / panel</td></tr>
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
<div class="lt-modal-footer">
|
||||
<button type="button" class="lt-btn" data-modal-close>Close</button>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- SETTINGS MODAL -->
|
||||
<div id="lt-settings-modal" class="lt-modal-overlay" aria-hidden="true">
|
||||
<div class="lt-modal" role="dialog" aria-modal="true" aria-labelledby="settings-modal-title">
|
||||
<div class="lt-modal-header">
|
||||
<span class="lt-modal-title" id="settings-modal-title">Settings</span>
|
||||
<button type="button" class="lt-modal-close" data-modal-close aria-label="Close">✕</button>
|
||||
</div>
|
||||
<div class="lt-modal-body">
|
||||
<div class="lt-form-group">
|
||||
<label class="lt-label">Auto-refresh interval</label>
|
||||
<div class="duration-pills" id="settings-refresh-pills" role="group" aria-label="Select auto-refresh interval">
|
||||
<button type="button" class="pill" data-refresh-interval="15" aria-pressed="false">15 s</button>
|
||||
<button type="button" class="pill" data-refresh-interval="30" aria-pressed="false">30 s</button>
|
||||
<button type="button" class="pill" data-refresh-interval="60" aria-pressed="false">1 min</button>
|
||||
<button type="button" class="pill" data-refresh-interval="300" aria-pressed="false">5 min</button>
|
||||
<button type="button" class="pill" data-refresh-interval="0" aria-pressed="false">Off</button>
|
||||
</div>
|
||||
<div class="lt-field-hint" id="settings-refresh-hint"></div>
|
||||
</div>
|
||||
<div class="lt-divider lt-divider--compact"></div>
|
||||
<div class="lt-kv-grid">
|
||||
<span class="lt-kv-key">User</span>
|
||||
<span class="lt-kv-val lt-kv-val--cyan">{{ user.name or user.username }}</span>
|
||||
{% if user.groups %}
|
||||
<span class="lt-kv-key">Groups</span>
|
||||
<span class="lt-kv-val">{{ user.groups | join(', ') }}</span>
|
||||
{% endif %}
|
||||
</div>
|
||||
</div>
|
||||
<div class="lt-modal-footer">
|
||||
<button type="button" class="lt-btn" data-modal-close>Close</button>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<script>
|
||||
const GANDALF_CONFIG = {
|
||||
ticket_web_url: {{ config.get('ticket_api', {}).get('web_url', 'http://t.lotusguild.org/ticket/') | tojson }}
|
||||
};
|
||||
</script>
|
||||
<script src="{{ url_for('static', filename='app.js') }}"></script>
|
||||
{% block scripts %}{% endblock %}
|
||||
|
||||
<script>
|
||||
if (window.lt) {
|
||||
lt.init({ bootName: 'GANDALF' });
|
||||
|
||||
// Theme toggle
|
||||
const themeBtn = document.getElementById('lt-theme-btn');
|
||||
if (themeBtn) themeBtn.addEventListener('click', function() { lt.theme.toggle(); });
|
||||
|
||||
// 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-topology', group: 'Navigate', icon: '⛓', label: 'Topology', action: function() { window.location.href = '/topology'; } },
|
||||
{ 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'; } },
|
||||
{ id: 'help-shortcuts', group: 'Help', icon: '?', label: 'Keyboard Shortcuts', kbd: '?', action: function() { lt.modal.open('lt-keys-help'); } },
|
||||
{ id: 'help-settings', group: 'Help', icon: '*', label: 'Settings', kbd: '*', action: function() { lt.modal.open('lt-settings-modal'); } },
|
||||
{ id: 'help-theme', group: 'Help', icon: '☀', label: 'Toggle Theme', action: function() { lt.theme.toggle(); } },
|
||||
]);
|
||||
}
|
||||
|
||||
// ── More menu: close on a click elsewhere or Escape ───────────────────
|
||||
document.addEventListener('click', function(e) {
|
||||
document.querySelectorAll('.g-nav-more[open]').forEach(function(d) {
|
||||
if (!d.contains(e.target)) d.removeAttribute('open');
|
||||
});
|
||||
});
|
||||
document.addEventListener('keydown', function(e) {
|
||||
if (e.key !== 'Escape') return;
|
||||
document.querySelectorAll('.g-nav-more[open]').forEach(function(d) {
|
||||
d.removeAttribute('open');
|
||||
d.querySelector('summary').focus();
|
||||
});
|
||||
});
|
||||
|
||||
// ── Global footer + key actions ───────────────────────────────────────
|
||||
document.addEventListener('click', function(e) {
|
||||
const btn = e.target.closest('[data-action]');
|
||||
if (!btn) return;
|
||||
const action = btn.getAttribute('data-action');
|
||||
if (action === 'open-cmdpalette' && window.lt && lt.cmdPalette) lt.cmdPalette.open();
|
||||
if (action === 'show-keyboard-help' && window.lt) lt.modal.open('lt-keys-help');
|
||||
if (action === 'open-settings' && window.lt) lt.modal.open('lt-settings-modal');
|
||||
});
|
||||
|
||||
lt.keys.on('r', function() { lt.autoRefresh.now(); });
|
||||
lt.keys.on('?', function() { if (window.lt) lt.modal.open('lt-keys-help'); });
|
||||
lt.keys.on('*', function() { if (window.lt) lt.modal.open('lt-settings-modal'); });
|
||||
lt.keys.on('s', function() {
|
||||
if (typeof openSuppressModal === 'function') openSuppressModal('host', '', '');
|
||||
});
|
||||
|
||||
// ── Avatar image error fallback ───────────────────────────────────────
|
||||
document.addEventListener('error', function(e) {
|
||||
if (e.target.tagName === 'IMG' && e.target.closest('.lt-avatar')) {
|
||||
e.target.classList.add('lt-avatar-img-err');
|
||||
}
|
||||
}, true);
|
||||
|
||||
// ── Settings modal ────────────────────────────────────────────────────
|
||||
(function() {
|
||||
const LS_KEY = 'gandalf_settings';
|
||||
const DEFAULT = { refreshInterval: 30 };
|
||||
|
||||
function loadSettings() {
|
||||
try { return Object.assign({}, DEFAULT, JSON.parse(localStorage.getItem(LS_KEY) || '{}')); }
|
||||
catch(_) { return Object.assign({}, DEFAULT); }
|
||||
}
|
||||
|
||||
function saveSettings(s) {
|
||||
try { localStorage.setItem(LS_KEY, JSON.stringify(s)); } catch(_) {}
|
||||
if (typeof window.onGandalfSettingsChanged === 'function') window.onGandalfSettingsChanged(s);
|
||||
}
|
||||
|
||||
function applyRefreshPillUI(interval) {
|
||||
document.querySelectorAll('#settings-refresh-pills .pill').forEach(function(p) {
|
||||
const isActive = parseInt(p.dataset.refreshInterval) === interval;
|
||||
p.classList.toggle('active', isActive);
|
||||
p.setAttribute('aria-pressed', isActive ? 'true' : 'false');
|
||||
});
|
||||
const hint = document.getElementById('settings-refresh-hint');
|
||||
if (hint) {
|
||||
if (interval === 0) hint.textContent = 'Auto-refresh disabled.';
|
||||
else if (interval < 60) hint.textContent = 'Refreshes every ' + interval + ' seconds.';
|
||||
else hint.textContent = 'Refreshes every ' + Math.floor(interval/60) + ' minute' + (interval > 60 ? 's' : '') + '.';
|
||||
}
|
||||
}
|
||||
|
||||
// Init pill UI from saved settings
|
||||
const _settings = loadSettings();
|
||||
applyRefreshPillUI(_settings.refreshInterval);
|
||||
|
||||
// Expose for pages that need to read it (e.g. index.html for autoRefresh)
|
||||
window.gandalfSettings = _settings;
|
||||
|
||||
document.addEventListener('click', function(e) {
|
||||
const pill = e.target.closest('#settings-refresh-pills .pill[data-refresh-interval]');
|
||||
if (!pill) return;
|
||||
const interval = parseInt(pill.dataset.refreshInterval);
|
||||
_settings.refreshInterval = interval;
|
||||
saveSettings(_settings);
|
||||
applyRefreshPillUI(interval);
|
||||
});
|
||||
})();
|
||||
|
||||
// ── Notification Bell: shows active monitoring alerts ────────────────
|
||||
(function() {
|
||||
const bell = document.getElementById('lt-notif-bell');
|
||||
const panel = document.getElementById('lt-notif-panel');
|
||||
const list = document.getElementById('lt-notif-list');
|
||||
const clearBtn = document.getElementById('lt-notif-clear-btn');
|
||||
const wrapEl = document.getElementById('lt-notif-wrap');
|
||||
if (!bell || !panel) return;
|
||||
|
||||
let _open = false;
|
||||
let _lastEvents = [];
|
||||
const LS_READ_KEY = 'gandalf_notif_read_before';
|
||||
|
||||
function getReadBefore() {
|
||||
try { return parseInt(localStorage.getItem(LS_READ_KEY) || '0'); } catch(_) { return 0; }
|
||||
}
|
||||
function setReadBefore(ts) {
|
||||
try { localStorage.setItem(LS_READ_KEY, String(ts)); } catch(_) {}
|
||||
}
|
||||
|
||||
function esc(s) {
|
||||
return (window.lt && lt.escHtml) ? lt.escHtml(String(s)) : String(s).replace(/&/g,'&').replace(/</g,'<').replace(/>/g,'>');
|
||||
}
|
||||
|
||||
function toMs(dateStr) {
|
||||
if (!dateStr) return 0;
|
||||
return new Date(dateStr.replace(' UTC','Z').replace(' ','T')).getTime();
|
||||
}
|
||||
|
||||
function fmtAgo(dateStr) {
|
||||
const diff = Math.floor((Date.now() - toMs(dateStr)) / 1000);
|
||||
if (diff < 60) return diff + 's ago';
|
||||
if (diff < 3600) return Math.floor(diff/60) + 'm ago';
|
||||
if (diff < 86400) return Math.floor(diff/3600) + 'h ago';
|
||||
return Math.floor(diff/86400) + 'd ago';
|
||||
}
|
||||
|
||||
const SEV_DOT = { critical: 'var(--red)', warning: 'var(--amber)' };
|
||||
|
||||
function renderAlerts(events) {
|
||||
_lastEvents = events || [];
|
||||
const readBefore = getReadBefore();
|
||||
const active = _lastEvents.filter(function(e) { return e.severity !== 'info'; });
|
||||
const unreadCount = active.filter(function(e) { return toMs(e.last_seen) > readBefore; }).length;
|
||||
lt.notif.set(bell, unreadCount);
|
||||
|
||||
if (!active.length) {
|
||||
list.innerHTML = '<div class="lt-notif-empty">✔ No active alerts</div>';
|
||||
return;
|
||||
}
|
||||
list.innerHTML = active.slice(0, 25).map(function(e) {
|
||||
const isUnread = toMs(e.last_seen) > readBefore;
|
||||
const dotColor = SEV_DOT[e.severity] || 'var(--text-muted)';
|
||||
return '<div class="lt-notif-item' + (isUnread ? ' lt-notif-item--unread' : '') + '">' +
|
||||
'<div class="lt-notif-dot' + (isUnread ? '' : ' lt-notif-dot--read') + '" style="background:' + dotColor + '"></div>' +
|
||||
'<div class="lt-notif-item-body">' +
|
||||
'<div class="lt-notif-item-title">' + esc(e.target_name) + (e.target_detail ? ' · ' + esc(e.target_detail) : '') + '</div>' +
|
||||
'<div class="lt-notif-item-time">' + esc(e.event_type.replace(/_/g,' ')) + ' · ' + fmtAgo(e.last_seen) + '</div>' +
|
||||
'</div></div>';
|
||||
}).join('');
|
||||
}
|
||||
|
||||
function fetchAlerts(andRender) {
|
||||
fetch('/api/status', { credentials: 'same-origin' })
|
||||
.then(function(r) { return r.json(); })
|
||||
.then(function(data) {
|
||||
const events = data.events || [];
|
||||
if (andRender) {
|
||||
renderAlerts(events);
|
||||
} else {
|
||||
_lastEvents = events;
|
||||
const readBefore = getReadBefore();
|
||||
const active = events.filter(function(e) { return e.severity !== 'info'; });
|
||||
const unread = active.filter(function(e) { return toMs(e.last_seen) > readBefore; }).length;
|
||||
lt.notif.set(bell, unread);
|
||||
}
|
||||
})
|
||||
.catch(function() {
|
||||
if (andRender) list.innerHTML = '<div class="lt-notif-empty">Could not load</div>';
|
||||
});
|
||||
}
|
||||
|
||||
function openPanel() { _open = true; panel.removeAttribute('aria-hidden'); bell.setAttribute('aria-expanded','true'); fetchAlerts(true); }
|
||||
function closePanel() { _open = false; panel.setAttribute('aria-hidden','true'); bell.setAttribute('aria-expanded','false'); }
|
||||
|
||||
bell.addEventListener('click', function(e) { e.stopPropagation(); _open ? closePanel() : openPanel(); });
|
||||
|
||||
if (clearBtn) {
|
||||
clearBtn.addEventListener('click', function() {
|
||||
setReadBefore(Date.now());
|
||||
renderAlerts(_lastEvents);
|
||||
});
|
||||
}
|
||||
|
||||
document.addEventListener('click', function(e) { if (_open && wrapEl && !wrapEl.contains(e.target)) closePanel(); });
|
||||
document.addEventListener('keydown', function(e) { if (e.key === 'Escape' && _open) closePanel(); });
|
||||
|
||||
// Initial badge load + poll every 60 s
|
||||
fetchAlerts(false);
|
||||
setInterval(function() { fetchAlerts(_open); }, 60000);
|
||||
|
||||
// Allow refreshAll() to also push fresh events to the bell
|
||||
window.gandalfNotifUpdate = function(events) { renderAlerts(events); };
|
||||
})();
|
||||
</script>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,399 @@
|
||||
{% 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 the live 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 class="lt-tabs cs-tabs no-print" role="tablist" aria-label="Cutsheet sections">
|
||||
<button type="button" class="lt-tab active" role="tab" id="cs-tabbtn-cables" data-tab="cs-tab-cables" aria-controls="cs-tab-cables" aria-selected="true">Cables <span class="cs-tab-count" id="cs-tabcount-cables"></span></button>
|
||||
<button type="button" class="lt-tab" role="tab" id="cs-tabbtn-todo" data-tab="cs-tab-todo" aria-controls="cs-tab-todo" aria-selected="false">To do <span class="cs-tab-count" id="cs-tabcount-todo"></span></button>
|
||||
<button type="button" class="lt-tab" role="tab" id="cs-tabbtn-panels" data-tab="cs-tab-panels" aria-controls="cs-tab-panels" aria-selected="false">Patch panels</button>
|
||||
<button type="button" class="lt-tab" role="tab" id="cs-tabbtn-items" data-tab="cs-tab-items" aria-controls="cs-tab-items" aria-selected="false">Inventory <span class="cs-tab-count" id="cs-tabcount-items"></span></button>
|
||||
<button type="button" class="lt-tab" role="tab" id="cs-tabbtn-history" data-tab="cs-tab-history" aria-controls="cs-tab-history" aria-selected="false">History</button>
|
||||
</div>
|
||||
|
||||
<div class="lt-tab-panel active" id="cs-tab-cables" role="tabpanel" aria-labelledby="cs-tabbtn-cables">
|
||||
<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>
|
||||
<p class="cs-summary" id="cs-summary" aria-live="polite"></p>
|
||||
<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>
|
||||
</div>
|
||||
|
||||
<div class="lt-tab-panel" id="cs-tab-todo" role="tabpanel" aria-labelledby="cs-tabbtn-todo">
|
||||
<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">Live switch ports no cable record mentions. Add pre-fills what Gandalf knows.</p>
|
||||
<div id="cs-suggestions"></div>
|
||||
</section>
|
||||
|
||||
<section class="g-section no-print" id="cs-portnames-section">
|
||||
<div class="g-section-header">
|
||||
<h2 class="g-section-title">Port names in UniFi</h2>
|
||||
<span class="g-section-badge" id="cs-portnames-count">0</span>
|
||||
</div>
|
||||
<p class="cs-hint">Names that no longer fit what is plugged in. Rename them in UniFi; Gandalf never changes UniFi.</p>
|
||||
<div id="cs-portnames"></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">Cable IDs go on both ends of the cord, panel labels on the port. Tick each once it's stuck on.</p>
|
||||
<div id="cs-labels"></div>
|
||||
</section>
|
||||
</div>
|
||||
|
||||
<div class="lt-tab-panel" id="cs-tab-panels" role="tabpanel" aria-labelledby="cs-tabbtn-panels">
|
||||
<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">╚</span><span class="lt-frame-br">╝</span>
|
||||
<div class="lt-section-header">Trace a cord</div>
|
||||
<div class="lt-section-body">
|
||||
<p class="cs-hint">Press Start, then unplug the panel port's cord: the switch port that drops is where it goes.
|
||||
The device on it loses its link until you plug it back in.</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>
|
||||
</div>
|
||||
|
||||
<div class="lt-tab-panel" id="cs-tab-items" role="tabpanel" aria-labelledby="cs-tabbtn-items">
|
||||
<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. <a href="/rack">See them in the rack drawing →</a></p>
|
||||
<div id="cs-items"></div>
|
||||
</section>
|
||||
</div>
|
||||
|
||||
<div class="lt-tab-panel" id="cs-tab-history" role="tabpanel" aria-labelledby="cs-tabbtn-history">
|
||||
<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>
|
||||
</div>
|
||||
|
||||
<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">✕</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">✕</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 on</label>
|
||||
<select class="lt-select" id="cs-item-mount" name="mount">
|
||||
<option value="front">Front posts</option>
|
||||
<option value="rear">Rear posts</option>
|
||||
<option value="full">Both (full depth)</option>
|
||||
</select>
|
||||
</div>
|
||||
<div class="lt-form-group">
|
||||
<label class="lt-label" for="cs-item-facing">Ports face</label>
|
||||
<select class="lt-select" id="cs-item-facing" name="facing">
|
||||
<option value="front">Front</option>
|
||||
<option value="rear">Rear</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 class="lt-form-group">
|
||||
<label class="lt-label" for="cs-item-slot">Position on shelf</label>
|
||||
<input class="lt-input" id="cs-item-slot" name="slot" type="number" min="1" max="99" placeholder="1 = leftmost">
|
||||
</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">✕</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">✕</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 %}
|
||||
@@ -0,0 +1,83 @@
|
||||
{% extends "base.html" %}
|
||||
{% block title %}{{ device_name }}{% endblock %}
|
||||
|
||||
{% block content %}
|
||||
<div class="lt-page-header">
|
||||
<div>
|
||||
<p class="g-page-sub"><a href="{{ url_for('index') }}">← Dashboard</a></p>
|
||||
<h1 class="lt-page-title device-title">
|
||||
<span id="device-dot" class="dot-unknown"></span>
|
||||
<span>{{ device_name }}</span>
|
||||
</h1>
|
||||
<p class="g-page-sub" id="device-subtitle"></p>
|
||||
</div>
|
||||
<div id="device-actions" class="device-actions"></div>
|
||||
</div>
|
||||
|
||||
<div id="device-root"><div class="link-loading">Loading device</div></div>
|
||||
|
||||
<!-- Outside device-root: auto-refresh must not reset the filter or port panel -->
|
||||
<section class="g-section" id="device-ports" hidden>
|
||||
<div class="g-section-header"><h2 class="g-section-title" id="device-ports-title">Ports</h2></div>
|
||||
<div class="device-inspector" id="device-inspector">
|
||||
<div class="device-chassis" id="device-chassis" role="region" aria-label="Front panel"></div>
|
||||
<div class="inspector-panel" id="inspector-panel" role="complementary" aria-label="Port detail panel">
|
||||
<div class="inspector-panel-inner" id="inspector-panel-inner"></div>
|
||||
</div>
|
||||
<div class="lt-frame device-port-table">
|
||||
<span class="lt-frame-bl">╚</span>
|
||||
<span class="lt-frame-br">╝</span>
|
||||
<div class="lt-toolbar device-toolbar">
|
||||
<div class="lt-toolbar-left">
|
||||
<div class="lt-search">
|
||||
<input type="search" class="lt-input lt-search-input lt-search-input--sm" id="device-table-search"
|
||||
placeholder="Filter…" autocomplete="off" aria-label="Filter ports">
|
||||
</div>
|
||||
<div class="sev-pills" role="group" aria-label="Filter by state">
|
||||
<button type="button" class="pill active" data-device-filter="all" aria-pressed="true">All</button>
|
||||
<button type="button" class="pill" data-device-filter="up" aria-pressed="false">Up</button>
|
||||
<button type="button" class="pill" data-device-filter="problems" aria-pressed="false">Errors (<span id="device-error-count">0</span>)</button>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<div id="device-table-wrap"></div>
|
||||
</div>
|
||||
</div>
|
||||
</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">✕</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 }};
|
||||
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 %}
|
||||
@@ -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 raised, including ones that cleared on their own; 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">╚</span><span class="lt-frame-br">╝</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">╚</span><span class="lt-frame-br">╝</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 %}
|
||||
@@ -0,0 +1,376 @@
|
||||
{% extends "base.html" %}
|
||||
{% block title %}Dashboard{% endblock %}
|
||||
|
||||
{% block content %}
|
||||
|
||||
<!-- ── Status bar ──────────────────────────────────────────────────── -->
|
||||
<div class="status-bar">
|
||||
<div class="status-chips" id="status-chips" aria-live="polite" aria-atomic="true">
|
||||
{% if not daemon_ok %}
|
||||
<span class="chip chip-critical">⚠ MONITOR OFFLINE</span>
|
||||
{% endif %}
|
||||
{% if summary.critical %}
|
||||
<span class="chip chip-critical">● {{ summary.critical }} CRITICAL</span>
|
||||
{% endif %}
|
||||
{% if summary.warning %}
|
||||
<span class="chip chip-warning">● {{ summary.warning }} WARNING</span>
|
||||
{% endif %}
|
||||
{% if daemon_ok and not summary.critical and not summary.warning %}
|
||||
<span class="chip chip-ok">✔ ALL SYSTEMS NOMINAL</span>
|
||||
{% endif %}
|
||||
{% set followups = (stale_tickets | length) + (stale_alerts or 0) %}
|
||||
{% if followups %}
|
||||
<a class="chip chip-warning chip-followup" href="{{ '#followup' if stale_tickets else '#events-table-wrap' }}">⏳ {{ followups }} TO FOLLOW UP</a>
|
||||
{% endif %}
|
||||
</div>
|
||||
<div class="status-meta">
|
||||
<span class="last-check" id="last-check" data-tooltip="Last monitor poll timestamp" data-tooltip-pos="bottom">{{ last_check }}</span>
|
||||
<span class="lt-spinner lt-spinner--sm lt-spinner--cyan" id="refresh-spinner" style="display:none"></span>
|
||||
<button class="lt-btn lt-btn-ghost lt-btn-sm" data-action="refresh" data-tooltip="Refresh all data now" data-tooltip-pos="bottom">↻ REFRESH</button>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- ── Needs attention: every page's problems in one place ──────────── -->
|
||||
<section class="g-section attention" id="attention" aria-labelledby="attention-title">
|
||||
<div class="g-section-header"><h2 class="g-section-title" id="attention-title">Needs attention</h2></div>
|
||||
<div class="attention-groups" id="attention-body" aria-live="polite">
|
||||
<p class="attention-empty">Checking every page…</p>
|
||||
</div>
|
||||
</section>
|
||||
|
||||
<!-- ── Device search ──────────────────────────────────────────────── -->
|
||||
<section class="g-section device-search" id="device-search" role="search">
|
||||
<label class="g-section-title" for="device-search-input">Find a device</label>
|
||||
<div class="lt-search">
|
||||
<input type="search" class="lt-input lt-search-input device-search-input" id="device-search-input"
|
||||
placeholder="Hostname, IP, MAC, model, interface… ( / )" autocomplete="off" spellcheck="false"
|
||||
role="combobox" aria-expanded="false" aria-controls="device-search-results" aria-autocomplete="list">
|
||||
</div>
|
||||
<div class="device-search-results" id="device-search-results" role="listbox" hidden></div>
|
||||
</section>
|
||||
|
||||
<!-- ── Active alerts ─────────────────────────────── (above the fold) -->
|
||||
<section class="g-section">
|
||||
<div class="g-section-header">
|
||||
<h2 class="g-section-title">Active Alerts</h2>
|
||||
<span class="g-section-badge g-section-badge-alert" id="alert-count-badge"
|
||||
{% if not summary.critical and not summary.warning %}style="display:none"{% endif %}>{{ (summary.critical or 0) + (summary.warning or 0) }}</span>
|
||||
</div>
|
||||
<div class="lt-toolbar">
|
||||
<div class="lt-toolbar-left">
|
||||
<div class="lt-search">
|
||||
<input type="search" class="lt-input lt-search-input" id="events-search"
|
||||
placeholder="Filter by target, type, description…" autocomplete="off"
|
||||
aria-label="Filter active alerts">
|
||||
</div>
|
||||
<div class="sev-pills" role="group" aria-label="Filter by severity">
|
||||
<button type="button" class="pill active" data-sev="" aria-pressed="true">All</button>
|
||||
<button type="button" class="pill" data-sev="critical" aria-pressed="false">Critical</button>
|
||||
<button type="button" class="pill" data-sev="warning" aria-pressed="false">Warning</button>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<div class="lt-frame">
|
||||
<span class="lt-frame-bl">╚</span>
|
||||
<span class="lt-frame-br">╝</span>
|
||||
<div class="lt-section-header">Alert Queue</div>
|
||||
<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>
|
||||
{% endif %}
|
||||
<div class="lt-table-wrap">
|
||||
<table class="lt-table lt-table-responsive" id="events-table">
|
||||
<caption class="lt-sr-only">Active network alerts</caption>
|
||||
<thead>
|
||||
<tr>
|
||||
<th data-tooltip="Alert severity level" data-tooltip-pos="bottom">Sev</th>
|
||||
<th>Type</th>
|
||||
<th>Target</th>
|
||||
<th>Detail</th>
|
||||
<th>Description</th>
|
||||
<th data-tooltip="When this alert was first raised" data-tooltip-pos="bottom">First Seen</th>
|
||||
<th data-tooltip="Most recent check failure" data-tooltip-pos="bottom">Last Seen</th>
|
||||
<th data-tooltip="Consecutive check failures since first seen" data-tooltip-pos="bottom">Failures</th>
|
||||
<th>Ticket</th>
|
||||
<th>Actions</th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
{% for e in events %}
|
||||
{% if e.severity != 'info' %}
|
||||
<tr class="row-{{ e.severity }}{% if e.is_suppressed %} row-suppressed{% endif %}">
|
||||
<td data-label="Sev">
|
||||
<span class="lt-badge badge-{{ e.severity }}">{{ e.severity }}</span>
|
||||
{% if e.is_suppressed %}<span class="lt-badge badge-suppressed" title="Alert suppressed">🔕 sup</span>{% endif %}
|
||||
{% if e.stale_days is not none %}<span class="lt-badge badge-stale" title="Active for {{ e.stale_days }} days with no fix yet">⏳ {{ e.stale_days }}d</span>{% endif %}
|
||||
{% if e.ticket_closed %}<span class="lt-badge badge-ticket-closed" title="Ticket #{{ e.ticket_id }} was closed in Tinker, but this alert is still active">ticket closed</span>{% endif %}
|
||||
</td>
|
||||
<td data-label="Type">{{ e.event_type | replace('_', ' ') }}</td>
|
||||
<td data-label="Target"><strong>{{ e.target_name }}</strong></td>
|
||||
<td data-label="Detail">{{ e.target_detail or '-' }}</td>
|
||||
<td data-label="Description" class="desc-cell" title="{{ e.description | e }}">{{ e.description | truncate(60) }}</td>
|
||||
<td data-label="First seen" class="ts-cell" title="{{ e.first_seen }}">
|
||||
<span class="event-age" data-ts="{{ e.first_seen }}">{{ e.first_seen }}</span>
|
||||
</td>
|
||||
<td data-label="Last seen" class="ts-cell" title="{{ e.last_seen }}">
|
||||
<span class="event-age" data-ts="{{ e.last_seen }}">{{ e.last_seen }}</span>
|
||||
</td>
|
||||
<td data-label="Failures">{{ e.consecutive_failures }}</td>
|
||||
<td data-label="Ticket">
|
||||
{% 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 %}
|
||||
</td>
|
||||
<td data-label="Actions">
|
||||
<button class="lt-btn lt-btn-ghost lt-btn-sm btn-suppress"
|
||||
data-sup-type="{{ 'unifi_device' if e.event_type == 'unifi_device_offline' else 'interface' if e.event_type == 'interface_down' else 'host' }}"
|
||||
data-sup-name="{{ e.target_name }}"
|
||||
data-sup-detail="{{ e.target_detail or '' }}"
|
||||
title="Suppress" aria-label="Suppress alert for {{ e.target_name }}">🔕</button>
|
||||
</td>
|
||||
</tr>
|
||||
{% endif %}
|
||||
{% else %}
|
||||
<tr><td colspan="10">
|
||||
<div class="lt-empty-state lt-empty-state--sm">
|
||||
<div class="lt-empty-state-icon">✔</div>
|
||||
<div class="lt-empty-state-title">No active alerts</div>
|
||||
</div>
|
||||
</td></tr>
|
||||
{% endfor %}
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
{% else %}
|
||||
<div class="lt-empty-state lt-empty-state--sm">
|
||||
<div class="lt-empty-state-icon">✔</div>
|
||||
<div class="lt-empty-state-title">No active alerts</div>
|
||||
</div>
|
||||
{% endif %}
|
||||
</div><!-- /#events-table-wrap -->
|
||||
</div><!-- /.lt-frame -->
|
||||
</section>
|
||||
|
||||
<!-- ── Needs follow-up: tickets left open after their alert cleared ── -->
|
||||
<section class="g-section" id="followup"{% if not stale_tickets %} hidden{% endif %}>
|
||||
<div class="g-section-header">
|
||||
<h2 class="g-section-title">Needs Follow-up</h2>
|
||||
<span class="g-section-badge g-section-badge-alert" id="followup-badge">{{ stale_tickets | length }}</span>
|
||||
</div>
|
||||
<p class="followup-intro">These tickets are still open in Tinker, but their alert cleared over a day ago. Close them if the problem is fixed.</p>
|
||||
<div class="lt-frame">
|
||||
<span class="lt-frame-bl">╚</span>
|
||||
<span class="lt-frame-br">╝</span>
|
||||
<div class="lt-section-header">Tickets Left Open</div>
|
||||
<div class="lt-table-wrap">
|
||||
<table class="lt-table" id="followup-table">
|
||||
<caption class="lt-sr-only">Tickets still open after their alert cleared</caption>
|
||||
<thead>
|
||||
<tr><th>Ticket</th><th>Target</th><th>Alert</th><th>Cleared</th><th>Alerts on ticket</th></tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
{% for t in stale_tickets %}
|
||||
<tr>
|
||||
<td><a href="{{ config.ticket_api.web_url }}{{ t.ticket_id }}" target="_blank" rel="noopener" class="ticket-link">#{{ t.ticket_id }}</a></td>
|
||||
<td><strong>{{ t.target_name }}</strong></td>
|
||||
<td>{{ t.event_type | replace('_', ' ') }}{% if t.target_detail %} <span class="lt-text-muted">{{ t.target_detail }}</span>{% endif %}</td>
|
||||
<td class="ts-cell" title="{{ t.cleared_at }}"><span class="event-age" data-ts="{{ t.cleared_at }}">{{ t.cleared_at }}</span></td>
|
||||
<td>{{ t.events }}</td>
|
||||
</tr>
|
||||
{% endfor %}
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
</div>
|
||||
</section>
|
||||
|
||||
<!-- ── WAN / fiber ──────────────────────────────────────────────────── -->
|
||||
{% include "_modem_panel.html" %}
|
||||
|
||||
<!-- ── Hosts ────────────────────────────────────────────────────────── -->
|
||||
<section class="g-section">
|
||||
<div class="g-section-header">
|
||||
<h2 class="g-section-title">Hosts</h2>
|
||||
</div>
|
||||
<div class="host-grid" id="host-grid">
|
||||
{%- set has_global_sup = suppressions | selectattr('target_type', 'equalto', 'all') | list | length > 0 -%}
|
||||
{% for name, host in snapshot.hosts.items() %}
|
||||
{% set suppressed = suppressions | selectattr('target_name', 'equalto', name) | list %}
|
||||
<div class="host-card host-card-{{ host.status }}" data-host="{{ name }}">
|
||||
<div class="host-card-header">
|
||||
<div class="host-name-row">
|
||||
<span class="host-status-dot dot-{{ host.status }}"></span>
|
||||
<a class="host-name device-link" href="{{ url_for('device_page', name=name) }}">{{ name }}</a>
|
||||
{% if suppressed or has_global_sup %}
|
||||
<span class="badge-suppressed" title="Suppressed">🔕</span>
|
||||
{% endif %}
|
||||
<button class="lt-btn lt-btn-ghost lt-btn-sm btn-suppress host-suppress"
|
||||
data-sup-type="host" data-sup-name="{{ name }}" data-sup-detail=""
|
||||
title="Suppress alerts for {{ name }}" aria-label="Suppress alerts for {{ name }}">🔕</button>
|
||||
</div>
|
||||
<div class="host-meta">
|
||||
<span class="host-ip">{{ host.ip }}</span>
|
||||
{% if host.source != 'prometheus' %}<span class="host-source source-{{ host.source }}">{{ host.source }}</span>{% endif %}
|
||||
</div>
|
||||
</div>
|
||||
|
||||
{% if host.interfaces %}
|
||||
{% set in_use = host.interfaces | dictsort | rejectattr(1, 'equalto', 'unused') | list %}
|
||||
{% set unused = (host.interfaces | length) - (in_use | length) %}
|
||||
<div class="iface-list">
|
||||
{% for iface, state in in_use %}
|
||||
<div class="iface-row">
|
||||
<span class="iface-dot dot-{{ state }}"></span>
|
||||
<span class="iface-name">{{ iface }}</span>
|
||||
<span class="iface-state state-{{ state }}">{{ state }}</span>
|
||||
</div>
|
||||
{% endfor %}
|
||||
{% if unused %}<div class="iface-unused">+{{ unused }} unused</div>{% endif %}
|
||||
</div>
|
||||
{% else %}
|
||||
<div class="host-ping-note">{% if host.source == 'ping' %}ping-only / no node_exporter{% else %}no metrics from node_exporter{% endif %}</div>
|
||||
{% endif %}
|
||||
</div>
|
||||
{% else %}
|
||||
<div class="lt-empty-state lt-empty-state--sm">
|
||||
<div class="lt-empty-state-icon">⌛</div>
|
||||
<div class="lt-empty-state-title">No host data yet</div>
|
||||
<div class="lt-empty-state-body">The monitor daemon may still be starting up.</div>
|
||||
</div>
|
||||
{% endfor %}
|
||||
</div>
|
||||
</section>
|
||||
|
||||
<!-- ── UniFi devices ────────────────────────────────────────────────── -->
|
||||
{% if snapshot.unifi %}
|
||||
<section class="g-section">
|
||||
<div class="g-section-header">
|
||||
<h2 class="g-section-title">UniFi Devices</h2>
|
||||
</div>
|
||||
<ul class="unifi-grid" id="unifi-grid">
|
||||
{% for d in snapshot.unifi %}
|
||||
<li class="unifi-chip{% if not d.connected %} unifi-chip-down{% endif %}">
|
||||
<span class="dot-{{ 'up' if d.connected else 'down' }}" title="{{ 'Online' if d.connected else 'Offline' }}"></span>
|
||||
<a class="device-link unifi-chip-name" href="{{ url_for('device_page', name=d.name) }}">{{ d.name }}</a>
|
||||
<span class="unifi-chip-model">{{ d.model }}</span>
|
||||
{% if not d.connected %}
|
||||
<button class="lt-btn lt-btn-ghost lt-btn-sm btn-suppress" data-sup-type="unifi_device"
|
||||
data-sup-name="{{ d.name }}" data-sup-detail="" title="Suppress alerts for {{ d.name }}"
|
||||
aria-label="Suppress alerts for {{ d.name }}">🔕</button>
|
||||
{% endif %}
|
||||
</li>
|
||||
{% endfor %}
|
||||
</ul>
|
||||
</section>
|
||||
{% endif %}
|
||||
|
||||
<!-- ── Recently Resolved (last 24h) ───────────────────────────────── -->
|
||||
{% if recent_resolved %}
|
||||
<details class="g-section resolved-fold">
|
||||
<summary class="g-section-header">
|
||||
<h2 class="g-section-title">Recently Resolved</h2>
|
||||
<span class="g-section-badge g-section-badge-resolved">{{ recent_resolved | length }} in last 24h</span>
|
||||
</summary>
|
||||
<div class="lt-timeline">
|
||||
{% for e in recent_resolved %}
|
||||
{%- set dot_cls = 'lt-timeline-item--green' if e.severity == 'info' else 'lt-timeline-item--dim' -%}
|
||||
<div class="lt-timeline-item {{ dot_cls }}">
|
||||
<div class="lt-timeline-meta">
|
||||
<strong class="lt-timeline-actor">{{ e.target_name }}</strong>
|
||||
{% if e.target_detail %}<span>· {{ e.target_detail }}</span>{% endif %}
|
||||
<span class="lt-timeline-time event-age" data-ts="{{ e.resolved_at }}">{{ e.resolved_at }}</span>
|
||||
</div>
|
||||
<div class="lt-timeline-body">
|
||||
{{ e.event_type | replace('_', ' ') }}
|
||||
·
|
||||
<span class="lt-badge badge-resolved">{{ e.severity }}</span>
|
||||
· duration
|
||||
<span class="event-duration" data-first="{{ e.first_seen }}" data-resolved="{{ e.resolved_at }}">-</span>
|
||||
</div>
|
||||
</div>
|
||||
{% endfor %}
|
||||
</div>
|
||||
</details>
|
||||
{% endif %}
|
||||
|
||||
{% endblock %}
|
||||
|
||||
{% block scripts %}
|
||||
<script>
|
||||
// Load once even when auto-refresh is set to Off
|
||||
refreshModem();
|
||||
refreshAttention();
|
||||
|
||||
// Start auto-refresh using saved settings interval (default 30 s)
|
||||
const _savedInterval = window.gandalfSettings?.refreshInterval ?? 30;
|
||||
if (_savedInterval > 0) lt.autoRefresh.start(refreshAll, _savedInterval * 1000);
|
||||
|
||||
// When settings change, restart auto-refresh with new interval
|
||||
window.onGandalfSettingsChanged = function(s) {
|
||||
lt.autoRefresh.stop();
|
||||
if (s.refreshInterval > 0) lt.autoRefresh.start(refreshAll, s.refreshInterval * 1000);
|
||||
};
|
||||
|
||||
function updateEventAges() {
|
||||
document.querySelectorAll('.event-age[data-ts]').forEach(el => {
|
||||
el.textContent = lt.time.ago(_toIso(el.dataset.ts));
|
||||
});
|
||||
}
|
||||
|
||||
updateEventAges();
|
||||
setInterval(updateEventAges, 60000);
|
||||
|
||||
// ── Event duration (resolved_at - first_seen) ──────────────────
|
||||
function fmtDuration(firstTs, resolvedTs) {
|
||||
if (!firstTs || !resolvedTs) return '-';
|
||||
const secs = Math.floor((new Date(_toIso(resolvedTs)) - new Date(_toIso(firstTs))) / 1000);
|
||||
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`;
|
||||
return `${Math.floor(secs/86400)}d`;
|
||||
}
|
||||
|
||||
document.querySelectorAll('.event-duration[data-first][data-resolved]').forEach(el => {
|
||||
el.textContent = fmtDuration(el.dataset.first, el.dataset.resolved);
|
||||
});
|
||||
|
||||
// ── Events table filter ────────────────────────────────────────
|
||||
let _filterSev = '';
|
||||
|
||||
function applyEventsFilter() {
|
||||
const q = (document.getElementById('events-search')?.value || '').toLowerCase();
|
||||
const tbody = document.querySelector('#events-table tbody');
|
||||
if (!tbody) return;
|
||||
tbody.querySelectorAll('tr').forEach(row => {
|
||||
if (row.children.length < 3) { row.style.display = ''; return; }
|
||||
const sevMatch = !_filterSev || row.classList.contains(`row-${_filterSev}`);
|
||||
const textMatch = !q || row.textContent.toLowerCase().includes(q);
|
||||
row.style.display = (sevMatch && textMatch) ? '' : 'none';
|
||||
});
|
||||
}
|
||||
|
||||
document.getElementById('events-search')?.addEventListener('input', applyEventsFilter);
|
||||
|
||||
document.querySelector('.sev-pills')?.addEventListener('click', e => {
|
||||
const pill = e.target.closest('.pill[data-sev]');
|
||||
if (!pill) return;
|
||||
document.querySelectorAll('.sev-pills .pill').forEach(p => {
|
||||
p.classList.remove('active');
|
||||
p.setAttribute('aria-pressed', 'false');
|
||||
});
|
||||
pill.classList.add('active');
|
||||
pill.setAttribute('aria-pressed', 'true');
|
||||
_filterSev = pill.dataset.sev;
|
||||
applyEventsFilter();
|
||||
});
|
||||
|
||||
// Re-apply filter after dynamic table updates
|
||||
new MutationObserver(applyEventsFilter)
|
||||
.observe(document.getElementById('events-table-wrap'), { childList: true, subtree: true });
|
||||
|
||||
initDeviceSearch();
|
||||
</script>
|
||||
{% endblock %}
|
||||
@@ -0,0 +1,94 @@
|
||||
{% extends "base.html" %}
|
||||
{% block title %}Rack{% endblock %}
|
||||
|
||||
{% block content %}
|
||||
<div class="lt-page-header">
|
||||
<div>
|
||||
<h1 class="lt-page-title">Rack</h1>
|
||||
<div class="g-page-sub">The rack, drawn from the cutsheet with live port state.
|
||||
<details class="g-howto"><summary aria-label="How to use this page">?</summary><span>Hover a port to light up every port on the same cable run; click it to open the port or the cable.</span></details></div>
|
||||
</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"
|
||||
title="The front posts, seen from the front">Front</button>
|
||||
<button type="button" class="rack-face-btn" data-face="behind" aria-pressed="false"
|
||||
title="Gear on the rear posts, seen from the front (what is behind the front gear)">Rear posts</button>
|
||||
<button type="button" class="rack-face-btn" data-face="rear" aria-pressed="false"
|
||||
title="The rack seen from behind">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">✕</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 %}
|
||||
@@ -0,0 +1,340 @@
|
||||
{% extends "base.html" %}
|
||||
{% block title %}Suppressions{% endblock %}
|
||||
|
||||
{% block content %}
|
||||
|
||||
<div class="lt-page-header">
|
||||
<div>
|
||||
<h1 class="lt-page-title">Alert Suppressions</h1>
|
||||
<p class="g-page-sub">Maintenance windows and alert suppression rules.</p>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- ── Create suppression ─────────────────────────────────────────── -->
|
||||
<section class="g-section">
|
||||
<div class="g-section-header">
|
||||
<h2 class="g-section-title">Create Suppression</h2>
|
||||
</div>
|
||||
<div class="lt-card">
|
||||
<div class="lt-card-body">
|
||||
<form id="create-suppression-form">
|
||||
<div class="form-row">
|
||||
<div class="lt-form-group">
|
||||
<label class="lt-label" for="s-type">Target Type <span class="required">*</span></label>
|
||||
<select class="lt-select" id="s-type" name="target_type">
|
||||
<option value="host">Host (all interfaces)</option>
|
||||
<option value="interface">Specific Interface</option>
|
||||
<option value="unifi_device">UniFi Device</option>
|
||||
<option value="all">Global (suppress everything)</option>
|
||||
</select>
|
||||
</div>
|
||||
<div class="lt-form-group" id="name-group">
|
||||
<label class="lt-label" for="s-name">Target Name <span class="required">*</span></label>
|
||||
<input type="text" class="lt-input" id="s-name" name="target_name"
|
||||
placeholder="hostname or device name" autocomplete="off"
|
||||
required aria-required="true" list="target-name-list">
|
||||
<datalist id="target-name-list">
|
||||
{% for name in snapshot.hosts.keys() | sort %}
|
||||
<option value="{{ name }}">
|
||||
{% endfor %}
|
||||
</datalist>
|
||||
</div>
|
||||
<div class="lt-form-group" id="detail-group" style="display:none">
|
||||
<label class="lt-label" for="s-detail">Interface Name</label>
|
||||
<input type="text" class="lt-input" id="s-detail" name="target_detail"
|
||||
placeholder="e.g. enp35s0 or bond0" autocomplete="off">
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="form-row">
|
||||
<div class="lt-form-group form-group-wide">
|
||||
<label class="lt-label" for="s-reason">Reason <span class="required">*</span></label>
|
||||
<input type="text" class="lt-input" id="s-reason" name="reason"
|
||||
placeholder="e.g. Planned switch maintenance, replacing SFP on compute-storage-02/enp43s0"
|
||||
required aria-required="true">
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="form-row form-row-align">
|
||||
<div class="lt-form-group">
|
||||
<label class="lt-label">Duration</label>
|
||||
<div class="duration-pills" role="group" aria-label="Select suppression duration">
|
||||
<button type="button" class="pill" data-duration="30" aria-pressed="false" aria-label="30 minutes">30 min</button>
|
||||
<button type="button" class="pill" data-duration="60" aria-pressed="false" aria-label="1 hour">1 hr</button>
|
||||
<button type="button" class="pill" data-duration="240" aria-pressed="false" aria-label="4 hours">4 hr</button>
|
||||
<button type="button" class="pill" data-duration="480" aria-pressed="false" aria-label="8 hours">8 hr</button>
|
||||
<button type="button" class="pill pill-manual active" data-duration="" aria-pressed="true" aria-label="Manual, no expiry">Manual ∞</button>
|
||||
</div>
|
||||
<input type="hidden" id="s-expires" name="expires_minutes" value="">
|
||||
<div class="lt-field-hint" id="s-dur-hint">Persists until manually removed.</div>
|
||||
</div>
|
||||
<div class="lt-form-group form-group-submit">
|
||||
<button type="submit" class="lt-btn lt-btn-primary lt-btn-lg">🔕 Apply Suppression</button>
|
||||
</div>
|
||||
</div>
|
||||
</form>
|
||||
</div>
|
||||
</div>
|
||||
</section>
|
||||
|
||||
<!-- ── Active suppressions ────────────────────────────────────────── -->
|
||||
<section class="g-section" id="active-sup-section">
|
||||
<div class="g-section-header">
|
||||
<h2 class="g-section-title">Active Suppressions</h2>
|
||||
<span class="g-section-badge" id="active-sup-badge">{{ active | length }}</span>
|
||||
</div>
|
||||
<div id="active-sup-wrap">
|
||||
{% if active %}
|
||||
<div class="lt-frame">
|
||||
<span class="lt-frame-bl">╚</span>
|
||||
<span class="lt-frame-br">╝</span>
|
||||
<div class="lt-section-header">Active Rules</div>
|
||||
<div class="lt-table-wrap">
|
||||
<table class="lt-table" id="active-sup-table">
|
||||
<caption class="lt-sr-only">Active suppression rules</caption>
|
||||
<thead>
|
||||
<tr>
|
||||
<th>Type</th><th>Target</th><th>Detail</th><th>Reason</th>
|
||||
<th>By</th><th>Created</th><th>Expires</th><th>Actions</th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
{% for s in active %}
|
||||
<tr id="sup-row-{{ s.id }}">
|
||||
{%- 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.reason }}</td>
|
||||
<td>{{ s.suppressed_by }}</td>
|
||||
<td class="ts-cell">{{ s.created_at }}</td>
|
||||
<td class="ts-cell">{% if s.expires_at %}{{ s.expires_at }}{% else %}<em>manual</em>{% endif %}</td>
|
||||
<td>
|
||||
<button class="lt-btn lt-btn-danger lt-btn-sm" data-action="remove-sup" data-sup-id="{{ s.id }}"
|
||||
aria-label="Remove suppression for {{ s.target_name or 'global' }}">Remove</button>
|
||||
</td>
|
||||
</tr>
|
||||
{% endfor %}
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
</div>
|
||||
{% else %}
|
||||
<div class="lt-empty-state lt-empty-state--sm" id="no-active-msg">
|
||||
<div class="lt-empty-state-icon">🔕</div>
|
||||
<div class="lt-empty-state-title">No active suppressions</div>
|
||||
<div class="lt-empty-state-body">All alerts are active. Use the form above to silence a host or interface.</div>
|
||||
</div>
|
||||
{% endif %}
|
||||
</div>
|
||||
</section>
|
||||
|
||||
<!-- ── Suppression history ────────────────────────────────────────── -->
|
||||
<section class="g-section">
|
||||
<div class="g-section-header">
|
||||
<h2 class="g-section-title">History</h2>
|
||||
<span class="g-section-badge">{{ history | length }}</span>
|
||||
</div>
|
||||
{% if history %}
|
||||
<div class="lt-frame">
|
||||
<span class="lt-frame-bl">╚</span>
|
||||
<span class="lt-frame-br">╝</span>
|
||||
<div class="lt-section-header">Suppression Log</div>
|
||||
<div class="lt-table-wrap">
|
||||
<table class="lt-table lt-table-sm">
|
||||
<caption class="lt-sr-only">Suppression history</caption>
|
||||
<thead>
|
||||
<tr>
|
||||
<th>Type</th><th>Target</th><th>Detail</th><th>Reason</th>
|
||||
<th>By</th><th>Created</th><th>Expires</th><th>Active</th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
{% for s in history %}
|
||||
<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.reason }}</td>
|
||||
<td>{{ s.suppressed_by }}</td>
|
||||
<td class="ts-cell">{{ s.created_at }}</td>
|
||||
<td class="ts-cell">{% if s.expires_at %}{{ s.expires_at }}{% else %}<em>manual</em>{% endif %}</td>
|
||||
<td>
|
||||
{% if s.active %}
|
||||
<span class="lt-badge badge-ok">Yes</span>
|
||||
{% else %}
|
||||
<span class="lt-badge badge-neutral">No</span>
|
||||
{% endif %}
|
||||
</td>
|
||||
</tr>
|
||||
{% endfor %}
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
</div>
|
||||
{% else %}
|
||||
<div class="lt-empty-state lt-empty-state--sm">
|
||||
<div class="lt-empty-state-icon">📋</div>
|
||||
<div class="lt-empty-state-title">No suppression history yet</div>
|
||||
</div>
|
||||
{% endif %}
|
||||
</section>
|
||||
|
||||
<!-- ── Available targets reference ───────────────────────────────── -->
|
||||
<section class="g-section">
|
||||
<div class="g-section-header">
|
||||
<h2 class="g-section-title">Available Targets</h2>
|
||||
</div>
|
||||
<div class="lt-frame">
|
||||
<span class="lt-frame-bl">╚</span>
|
||||
<span class="lt-frame-br">╝</span>
|
||||
<div class="lt-section-header">Host & Interface Reference</div>
|
||||
<div class="lt-section-body">
|
||||
<div class="targets-grid">
|
||||
{% for name, host in snapshot.hosts.items() %}
|
||||
<div class="target-card">
|
||||
<div class="target-name">{{ name }}</div>
|
||||
<div class="target-type">{{ 'Proxmox Host (prometheus)' if host.source == 'prometheus' else 'Ping-only host' }}</div>
|
||||
{% if host.interfaces %}
|
||||
<div class="target-ifaces">
|
||||
{% for iface in host.interfaces.keys() | sort %}
|
||||
<code class="iface-chip">{{ iface }}</code>
|
||||
{% endfor %}
|
||||
</div>
|
||||
{% endif %}
|
||||
</div>
|
||||
{% endfor %}
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
</section>
|
||||
|
||||
{% endblock %}
|
||||
|
||||
{% block scripts %}
|
||||
<script>
|
||||
function onTypeChange() {
|
||||
const t = document.getElementById('s-type').value;
|
||||
document.getElementById('name-group').style.display = (t==='all') ? 'none' : '';
|
||||
document.getElementById('detail-group').style.display = (t==='interface') ? '' : 'none';
|
||||
const nameInput = document.getElementById('s-name');
|
||||
if (nameInput) {
|
||||
const req = (t !== 'all');
|
||||
nameInput.required = req;
|
||||
nameInput.setAttribute('aria-required', String(req));
|
||||
}
|
||||
}
|
||||
|
||||
function setDur(mins, el) {
|
||||
setDuration(mins, el, { expiresId: 's-expires', pillSel: '#create-suppression-form .pill', hintId: 's-dur-hint' });
|
||||
}
|
||||
|
||||
function renderActiveRows(rows) {
|
||||
const wrap = document.getElementById('active-sup-wrap');
|
||||
const badge = document.getElementById('active-sup-badge');
|
||||
if (!rows || !rows.length) {
|
||||
wrap.innerHTML = '<div class="lt-empty-state lt-empty-state--sm" id="no-active-msg"><div class="lt-empty-state-icon">🔕</div><div class="lt-empty-state-title">No active suppressions</div><div class="lt-empty-state-body">All alerts are active. Use the form above to silence a host or interface.</div></div>';
|
||||
if (badge) badge.textContent = '0';
|
||||
return;
|
||||
}
|
||||
if (badge) badge.textContent = rows.length;
|
||||
const SUP_BADGE = {host:'badge-warning', interface:'badge-info', unifi_device:'badge-purple', all:'badge-critical'};
|
||||
const tbody = rows.map(s => `
|
||||
<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.reason)}</td>
|
||||
<td>${lt.escHtml(s.suppressed_by)}</td>
|
||||
<td class="ts-cell">${lt.escHtml(s.created_at || '')}</td>
|
||||
<td class="ts-cell">${s.expires_at ? lt.escHtml(s.expires_at) : '<em>manual</em>'}</td>
|
||||
<td><button class="lt-btn lt-btn-danger lt-btn-sm" data-action="remove-sup" data-sup-id="${s.id}"
|
||||
aria-label="Remove suppression for ${lt.escHtml(s.target_name || 'global')}">Remove</button></td>
|
||||
</tr>`).join('');
|
||||
wrap.innerHTML = `
|
||||
<div class="lt-frame">
|
||||
<span class="lt-frame-bl">╚</span>
|
||||
<span class="lt-frame-br">╝</span>
|
||||
<div class="lt-section-header">Active Rules</div>
|
||||
<div class="lt-table-wrap">
|
||||
<table class="lt-table" id="active-sup-table">
|
||||
<caption class="lt-sr-only">Active suppression rules</caption>
|
||||
<thead><tr>
|
||||
<th>Type</th><th>Target</th><th>Detail</th><th>Reason</th>
|
||||
<th>By</th><th>Created</th><th>Expires</th><th>Actions</th>
|
||||
</tr></thead>
|
||||
<tbody>${tbody}</tbody>
|
||||
</table>
|
||||
</div>
|
||||
</div>`;
|
||||
}
|
||||
|
||||
async function refreshActive() {
|
||||
try {
|
||||
const rows = await lt.api.get('/api/suppressions');
|
||||
renderActiveRows(rows);
|
||||
} catch (err) {
|
||||
showToast('Failed to refresh suppressions', 'warning');
|
||||
}
|
||||
}
|
||||
|
||||
async function createSuppression(e) {
|
||||
e.preventDefault();
|
||||
const form = e.target;
|
||||
const btn = form.querySelector('[type="submit"]');
|
||||
btn.classList.add('is-loading');
|
||||
const payload = {
|
||||
target_type: form.target_type.value,
|
||||
target_name: form.target_name ? form.target_name.value : '',
|
||||
target_detail: document.getElementById('s-detail').value,
|
||||
reason: form.reason.value,
|
||||
expires_minutes: form.expires_minutes.value ? parseInt(form.expires_minutes.value) : null,
|
||||
};
|
||||
try {
|
||||
await lt.api.post('/api/suppressions', payload);
|
||||
showToast('Suppression applied', 'success');
|
||||
form.reset();
|
||||
onTypeChange();
|
||||
setDur(null, document.querySelector('#create-suppression-form .pill-manual'));
|
||||
await refreshActive();
|
||||
} catch (err) {
|
||||
showToast(err.message || 'Error', 'error');
|
||||
} finally {
|
||||
btn.classList.remove('is-loading');
|
||||
}
|
||||
}
|
||||
|
||||
async function removeSuppression(id) {
|
||||
if (!confirm('Remove this suppression?')) return;
|
||||
try {
|
||||
await lt.api.delete(`/api/suppressions/${id}`);
|
||||
document.getElementById(`sup-row-${id}`)?.remove();
|
||||
const badge = document.getElementById('active-sup-badge');
|
||||
if (badge) badge.textContent = Math.max(0, parseInt(badge.textContent || '0') - 1);
|
||||
const tbody = document.querySelector('#active-sup-table tbody');
|
||||
if (tbody && !tbody.children.length) {
|
||||
document.getElementById('active-sup-wrap').innerHTML =
|
||||
'<div class="lt-empty-state lt-empty-state--sm" id="no-active-msg"><div class="lt-empty-state-icon">🔕</div><div class="lt-empty-state-title">No active suppressions</div><div class="lt-empty-state-body">All alerts are active. Use the form above to silence a host or interface.</div></div>';
|
||||
if (badge) badge.textContent = '0';
|
||||
}
|
||||
showToast('Suppression removed', 'success');
|
||||
} catch (err) {
|
||||
showToast(err.message || 'Failed to remove suppression', 'error');
|
||||
}
|
||||
}
|
||||
|
||||
document.getElementById('s-type')?.addEventListener('change', onTypeChange);
|
||||
document.getElementById('create-suppression-form')?.addEventListener('submit', createSuppression);
|
||||
|
||||
document.addEventListener('click', e => {
|
||||
const pill = e.target.closest('#create-suppression-form .pill[data-duration]');
|
||||
if (pill) {
|
||||
const val = pill.dataset.duration;
|
||||
setDur(val ? parseInt(val) : null, pill);
|
||||
return;
|
||||
}
|
||||
const removeBtn = e.target.closest('[data-action="remove-sup"]');
|
||||
if (removeBtn) removeSuppression(parseInt(removeBtn.dataset.supId));
|
||||
});
|
||||
</script>
|
||||
{% endblock %}
|
||||
@@ -0,0 +1,64 @@
|
||||
{% extends "base.html" %}
|
||||
{% block title %}Topology{% endblock %}
|
||||
|
||||
{% block content %}
|
||||
<div class="lt-page-header">
|
||||
<div>
|
||||
<h1 class="lt-page-title">Topology</h1>
|
||||
<div class="g-page-sub">Every device and cable, as the switches see them now.
|
||||
<details class="g-howto"><summary aria-label="How to use this page">?</summary><span>Drag to pan; scroll or pinch to zoom. Hover a device to trace its path to the internet and its power (on a touch screen, tap once to trace and again to open it). Click a cable for its details, or a group of unknown devices to open it.</span></details></div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="tp-toolbar no-print" role="toolbar" aria-label="Topology view">
|
||||
<div class="tp-filters" role="group" aria-label="Show">
|
||||
<label class="tp-filter">Unknown devices
|
||||
<select class="lt-select tp-select" data-filter="stubs" aria-label="Unknown devices">
|
||||
<option value="grouped">grouped per switch</option>
|
||||
<option value="all">one by one</option>
|
||||
<option value="none">hidden</option>
|
||||
</select></label>
|
||||
<label class="tp-filter"><input type="checkbox" data-filter="power"> Power gear</label>
|
||||
<label class="tp-filter"><input type="checkbox" data-filter="traffic"> Traffic</label>
|
||||
<label class="tp-filter" title="Each server's slower second cable. A problem cable is always shown."><input type="checkbox" data-filter="mgmt"> Server 1G links</label>
|
||||
<label class="tp-filter"><input type="checkbox" data-filter="alerts"> Alerts only</label>
|
||||
</div>
|
||||
<div class="tp-zoom" role="group" aria-label="Zoom">
|
||||
<button type="button" class="lt-btn lt-btn-secondary lt-btn-sm" data-zoom="out" aria-label="Zoom out" title="Zoom out (-)">−</button>
|
||||
<button type="button" class="lt-btn lt-btn-secondary lt-btn-sm" data-zoom="fit" title="Fit everything (0)">Fit</button>
|
||||
<button type="button" class="lt-btn lt-btn-secondary lt-btn-sm" data-zoom="in" aria-label="Zoom in" title="Zoom in (+)">+</button>
|
||||
</div>
|
||||
<span class="tp-updated" id="tp-updated" aria-live="polite"></span>
|
||||
</div>
|
||||
|
||||
<div class="tp-warnings" id="tp-warnings" role="status" hidden></div>
|
||||
<div class="tp-summary" id="tp-summary" aria-live="polite"></div>
|
||||
|
||||
<div class="tp-canvas" id="tp-canvas" tabindex="0" aria-label="Network topology diagram. Use plus, minus and zero to zoom, and Tab to move between devices and cables.">
|
||||
<svg class="tp-svg" id="tp-svg" xmlns="http://www.w3.org/2000/svg" role="group" aria-label="Network topology">
|
||||
<g id="tp-world"></g>
|
||||
</svg>
|
||||
<div class="link-loading tp-loading" id="tp-loading">Loading topology</div>
|
||||
<aside class="tp-panel" id="tp-panel" hidden aria-live="polite" aria-label="Cable details"></aside>
|
||||
<div class="tp-pop" id="tp-pop" role="dialog" aria-label="What this outlet feeds" hidden></div>
|
||||
</div>
|
||||
|
||||
<div class="tp-legend" aria-label="Legend">
|
||||
<span class="tp-key"><svg viewBox="0 0 40 12" aria-hidden="true"><path class="tp-key-line tp-m-dac" d="M2 6 H38"/></svg>DAC</span>
|
||||
<span class="tp-key"><svg viewBox="0 0 40 12" aria-hidden="true"><path class="tp-key-line tp-m-fibre" d="M2 6 H38"/></svg>Fibre (multimode)</span>
|
||||
<span class="tp-key"><svg viewBox="0 0 40 12" aria-hidden="true"><path class="tp-key-line tp-m-wanfibre" d="M2 6 H38"/></svg>Fibre (provider)</span>
|
||||
<span class="tp-key"><svg viewBox="0 0 40 12" aria-hidden="true"><path class="tp-key-line tp-m-sfp" d="M2 6 H38"/></svg>SFP+ module</span>
|
||||
<span class="tp-key"><svg viewBox="0 0 40 12" aria-hidden="true"><path class="tp-key-line tp-m-copper" d="M2 6 H38"/></svg>Copper</span>
|
||||
<span class="tp-key">Thicker = faster (10G, 1G, 100M)</span>
|
||||
<span class="tp-key"><svg viewBox="0 0 40 12" aria-hidden="true"><path class="tp-key-line tp-key-down" d="M2 6 H38"/></svg>Down</span>
|
||||
<span class="tp-key"><svg viewBox="0 0 40 12" aria-hidden="true"><path class="tp-key-line tp-key-ghost" d="M2 6 H38"/></svg>Last seen</span>
|
||||
<span class="tp-key"><span class="tp-key-warn" aria-hidden="true">⚠</span>Port name points at another device</span>
|
||||
</div>
|
||||
{% endblock %}
|
||||
|
||||
{% block scripts %}
|
||||
<script>const TOPO_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='topology.js') }}"></script>
|
||||
{% endblock %}
|
||||
@@ -0,0 +1,939 @@
|
||||
"""Tests for app.py routes: database and LDAP are mocked."""
|
||||
import json
|
||||
import time
|
||||
from datetime import datetime, timedelta, timezone
|
||||
import os
|
||||
import sys
|
||||
from unittest.mock import MagicMock, patch
|
||||
|
||||
import pytest
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
|
||||
|
||||
import app as gandalf # noqa: E402
|
||||
|
||||
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'}}},
|
||||
'unifi': [{'name': 'USW Flex', 'type': 'usw', 'model': 'USF5P', 'ip': '10.0.0.3', 'mac': '',
|
||||
'connected': True}],
|
||||
}),
|
||||
'link_stats': json.dumps({'hosts': {}, 'unifi_switches': {}}),
|
||||
}
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def client():
|
||||
with patch.object(gandalf, 'db') as db:
|
||||
db.get_state.side_effect = lambda key, default=None: STATE.get(key, default)
|
||||
db.get_active_events.return_value = []
|
||||
db.get_recent_resolved.return_value = []
|
||||
db.get_active_suppressions.return_value = []
|
||||
db.get_events_for_target.return_value = []
|
||||
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
|
||||
db.get_device_link.return_value = ''
|
||||
db.cutsheet_racks.return_value = []
|
||||
db.get_unused_interfaces.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)
|
||||
assert 'id="device-search-input"' in html
|
||||
assert 'Link Debug' not in html
|
||||
|
||||
def test_home_section_order(self, client):
|
||||
html = client.get('/', headers=AUTH).get_data(as_text=True)
|
||||
order = [html.index(m) for m in (
|
||||
'id="attention"', 'id="device-search"', 'Alert Queue', 'WAN / Fiber', 'g-section-title">Hosts<',
|
||||
'id="unifi-grid"',
|
||||
)]
|
||||
assert order == sorted(order)
|
||||
# The needs-attention list replaced the stat cards
|
||||
assert 'lt-stat-card' not in html
|
||||
|
||||
def test_dashboard_topology_moved_to_its_own_page(self, client):
|
||||
html = client.get('/', headers=AUTH).get_data(as_text=True)
|
||||
assert 'topology-diagram' not in html and 'Network Topology' not in html
|
||||
assert 'href="/topology"' in html
|
||||
|
||||
def test_old_links_url_redirects_home(self, client):
|
||||
resp = client.get('/links', headers=AUTH)
|
||||
assert resp.status_code == 302 and resp.headers['Location'].endswith('/')
|
||||
|
||||
def test_device_page_escapes_name(self, client):
|
||||
html = client.get('/device/%3Cscript%3Ex', headers=AUTH).get_data(as_text=True)
|
||||
assert '<script>x' not in html
|
||||
|
||||
def test_old_inspector_url_redirects_home(self, client):
|
||||
resp = client.get('/inspector', headers=AUTH)
|
||||
assert resp.status_code == 302 and resp.headers['Location'].endswith('/')
|
||||
|
||||
def test_nav_has_no_inspector_link(self, client):
|
||||
assert '>Inspector<' not in client.get('/', headers=AUTH).get_data(as_text=True)
|
||||
assert 'Inspector' not in client.get('/device/large1', headers=AUTH).get_data(as_text=True).split('</nav>')[0]
|
||||
|
||||
def test_device_page_loads_the_port_inspector(self, client):
|
||||
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
|
||||
|
||||
|
||||
class TestDeviceApi:
|
||||
def test_requires_auth(self, client):
|
||||
assert client.get('/api/devices').status_code == 401
|
||||
assert client.get('/api/device/large1').status_code == 401
|
||||
|
||||
def test_index_lists_devices(self, client):
|
||||
names = [d['name'] for d in client.get('/api/devices', headers=AUTH).get_json()['devices']]
|
||||
assert names == ['large1', 'USW Flex']
|
||||
|
||||
def test_name_with_a_space(self, client):
|
||||
d = client.get('/api/device/USW%20Flex', headers=AUTH).get_json()
|
||||
assert d['kind'] == 'switch' and d['events'] == []
|
||||
|
||||
def test_unknown_device_is_404(self, client):
|
||||
assert client.get('/api/device/nope', headers=AUTH).status_code == 404
|
||||
|
||||
|
||||
class TestAvatarLogging:
|
||||
def test_missing_ldap_config_says_why(self, client, caplog):
|
||||
assert client.get('/api/avatar', headers=AUTH).status_code == 404
|
||||
assert 'no ldap' in caplog.text
|
||||
|
||||
|
||||
class TestDatabaseTimeZone:
|
||||
def test_sessions_run_in_utc(self):
|
||||
import db as real_db
|
||||
with patch.object(real_db.pymysql, 'connect') as connect:
|
||||
real_db._new_conn({'host': 'h', 'user': 'u', 'password': 'p', 'name': 'n'})
|
||||
assert connect.call_args.kwargs['init_command'] == "SET time_zone='+00:00'"
|
||||
|
||||
|
||||
class TestDiagnoseWithResolvedNeighbor:
|
||||
LINKS = json.dumps({
|
||||
'hosts': {'large1': {'enp35s0': {'host_ip': '10.0.0.2'}}},
|
||||
'unifi_switches': {'sw': {'ports': {'Port 4': {
|
||||
'port_idx': 4, 'up': True,
|
||||
'lldp': {'system_name': 'large1', 'port_id': 'enp35s0', 'chassis_id': 'aa:bb:cc:dd:ee:ff'},
|
||||
}}}},
|
||||
})
|
||||
|
||||
def test_port_with_a_named_neighbor_starts_a_job(self, client):
|
||||
STATE['link_stats'], saved = self.LINKS, STATE['link_stats']
|
||||
try:
|
||||
with patch.object(gandalf.threading, 'Thread'):
|
||||
resp = client.post('/api/diagnose', json={'switch_name': 'sw', 'port_idx': 4}, headers=AUTH)
|
||||
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'])
|
||||
assert isinstance(view['port_names'], list)
|
||||
|
||||
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'),
|
||||
('/topology', 'Topology | 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_three_views(self, client):
|
||||
# A server through both posts, a PDU on the rear posts facing the front (as in the StarTech),
|
||||
# a fan tray on the rear posts facing the rear, and a switch on the front posts
|
||||
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': 'Fans', 'kind': 'device', 'rack_u': 14, 'rack_height': 1, 'mount': 'rear',
|
||||
'facing': 'rear'},
|
||||
{'name': 'Switch', 'kind': 'device', 'rack_u': 12, 'rack_height': 1})
|
||||
|
||||
def view(face):
|
||||
return [(i['name'], i['through']) for i in
|
||||
client.get(f'/api/rack?face={face}', headers=AUTH).get_json()['items']]
|
||||
assert view('front') == [('Switch', False), ('Server', False)]
|
||||
assert view('behind') == [('Fans', True), ('PDU', False), ('Server', False)]
|
||||
assert view('rear') == [('Fans', False), ('PDU', True), ('Server', True)]
|
||||
racks = client.get('/api/rack', headers=AUTH).get_json()['racks'][0]
|
||||
assert (racks['count'], racks['rear'], racks['behind']) == (4, 3, 2)
|
||||
assert client.get('/api/rack?face=side', headers=AUTH).status_code == 400
|
||||
|
||||
def test_shelf_contents_ordered_with_nics(self, client):
|
||||
self._items({'name': 'Shelf', 'kind': 'shelf', 'rack_u': 3, 'rack_height': 2, 'mount': 'rear'},
|
||||
{'name': 'b-box', 'kind': 'device', 'shelf': 'Shelf', 'slot': 1, 'chassis': 'zimaboard-832'},
|
||||
{'name': 'large1', 'kind': 'device', 'shelf': 'Shelf', 'slot': 2})
|
||||
data = client.get('/api/rack?face=behind', headers=AUTH).get_json()
|
||||
things = data['items'][0]['contents']
|
||||
assert [(c['name'], c['slot'], c['chassis']) for c in things] == [('b-box', 1, 'zimaboard-832'),
|
||||
('large1', 2, '')]
|
||||
assert things[1]['interfaces'] == [{'name': 'eth0', 'up': True, 'unused': False}]
|
||||
assert things[0]['device'] == 'b-box' and things[0]['ports'] == {}
|
||||
|
||||
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
|
||||
|
||||
|
||||
class TestUnusedInterfaces:
|
||||
def _url(self, iface='nic1'):
|
||||
gandalf._cutsheet_schema_ready = True
|
||||
return f'/api/device/compute-storage-01/interfaces/{iface}/unused'
|
||||
|
||||
def test_mark_and_clear(self, client):
|
||||
assert client.put(self._url(), json={'reason': ' never cabled '}, headers=AUTH).status_code == 200
|
||||
gandalf.db.set_unused_interface.assert_called_with('compute-storage-01', 'nic1', 'never cabled', 'jared')
|
||||
gandalf.db.clear_unused_interface.return_value = True
|
||||
resp = client.delete(self._url(), headers=AUTH)
|
||||
assert resp.get_json() == {'success': True, 'changed': True}
|
||||
|
||||
def test_needs_admin_json_and_a_sane_name(self, client):
|
||||
user = dict(AUTH, **{'Remote-Groups': 'staff'})
|
||||
with patch.object(gandalf, '_cfg', dict(CONFIG, auth=dict(CONFIG['auth'], allowed_groups=['admin', 'staff']))):
|
||||
assert client.put(self._url(), json={}, headers=user).status_code == 403
|
||||
assert client.put(self._url(), data='x', headers=AUTH).status_code == 400
|
||||
assert client.put(self._url('bad name!'), json={}, headers=AUTH).status_code in (400, 404)
|
||||
|
||||
def test_device_api_lists_them(self, client):
|
||||
gandalf._cutsheet_schema_ready = True
|
||||
gandalf.db.get_unused_interfaces.return_value = {'large1': {'enp36s0': {'reason': 'spare'}}}
|
||||
data = client.get('/api/device/large1', headers=AUTH).get_json()
|
||||
assert data['unused_interfaces'] == {'enp36s0': {'reason': 'spare'}}
|
||||
|
||||
|
||||
class TestMaintenance:
|
||||
SUP = {'id': 7, 'target_type': 'all', 'target_name': '', 'reason': 'UniFi Network update',
|
||||
'suppressed_by': 'jared', 'expires_at': '2026-11-12T20:00:00Z'}
|
||||
|
||||
def test_no_banner_and_a_start_button_by_default(self, client):
|
||||
html = client.get('/', headers=AUTH).get_data(as_text=True)
|
||||
assert 'maint-banner' not in html
|
||||
assert 'data-action="start-maintenance"' in html and 'id="maint-modal"' in html
|
||||
|
||||
def test_banner_on_every_page_while_on(self, client):
|
||||
gandalf.db.get_active_suppressions.return_value = [
|
||||
{'id': 3, 'target_type': 'host', 'target_name': 'large1', 'reason': 'x', 'expires_at': None},
|
||||
self.SUP,
|
||||
]
|
||||
for page in ('/', '/events', '/rack'):
|
||||
html = client.get(page, headers=AUTH).get_data(as_text=True)
|
||||
assert 'class="maint-banner"' in html, page
|
||||
assert 'datetime="2026-11-12T20:00:00Z"' in html and 'UniFi Network update' in html
|
||||
assert 'data-sup-id="7"' in html and 'data-action="start-maintenance"' not in html
|
||||
|
||||
def test_open_ended_maintenance_wins(self, client):
|
||||
gandalf.db.get_active_suppressions.return_value = [
|
||||
self.SUP, dict(self.SUP, id=9, expires_at=None, reason='Rewiring')]
|
||||
html = client.get('/', headers=AUTH).get_data(as_text=True)
|
||||
assert 'until it is ended' in html and 'data-sup-id="9"' in html
|
||||
|
||||
def test_viewers_see_the_banner_without_buttons(self, client):
|
||||
gandalf.db.get_active_suppressions.return_value = [self.SUP]
|
||||
viewer = dict(AUTH, **{'Remote-Groups': 'staff'})
|
||||
with patch.object(gandalf, '_cfg', dict(CONFIG, auth=dict(CONFIG['auth'], allowed_groups=['admin', 'staff']))):
|
||||
html = client.get('/', headers=viewer).get_data(as_text=True)
|
||||
assert 'class="maint-banner"' in html and 'data-action="end-maintenance"' not in html
|
||||
|
||||
def test_a_db_error_means_no_banner(self, client):
|
||||
gandalf.db.get_active_suppressions.side_effect = RuntimeError('db down')
|
||||
assert gandalf.inject_maintenance() == {'maintenance': None}
|
||||
|
||||
|
||||
class TestFollowUp:
|
||||
def _state(self, tickets, age_s=60):
|
||||
state = dict(STATE, open_tickets=json.dumps({'checked_at': time.time() - age_s, 'tickets': tickets}))
|
||||
gandalf.db.get_state.side_effect = lambda key, default=None: state.get(key, default)
|
||||
|
||||
def _event(self, days_old, ticket_id=None):
|
||||
first = (datetime.now(timezone.utc) - timedelta(days=days_old)).strftime('%Y-%m-%dT%H:%M:%SZ')
|
||||
return {'id': 1, 'event_type': 'interface_down', 'severity': 'critical', 'target_name': 'micro1',
|
||||
'target_detail': 'enp3s0', 'description': 'down', 'first_seen': first, 'last_seen': first,
|
||||
'consecutive_failures': 3, 'ticket_id': ticket_id}
|
||||
|
||||
def test_old_alert_is_stale_and_closed_ticket_is_flagged(self, client):
|
||||
self._state({'9': 'Open'})
|
||||
gandalf.db.get_active_events.return_value = [self._event(5, '8'), self._event(1, '9')]
|
||||
gandalf.db.get_cleared_tickets.return_value = []
|
||||
events = client.get('/api/status', headers=AUTH).get_json()['events']
|
||||
assert events[0]['stale_days'] == 5 and events[0]['ticket_closed'] is True
|
||||
assert events[1]['stale_days'] is None and events[1]['ticket_closed'] is False
|
||||
|
||||
def test_threshold_comes_from_config(self, client):
|
||||
self._state({})
|
||||
gandalf.db.get_active_events.return_value = [self._event(1.5)]
|
||||
gandalf.db.get_cleared_tickets.return_value = []
|
||||
cfg = dict(CONFIG, monitor={'stale_alert_days': 1})
|
||||
with patch.object(gandalf, '_cfg', cfg):
|
||||
events = client.get('/api/status', headers=AUTH).get_json()['events']
|
||||
assert events[0]['stale_days'] == 1
|
||||
|
||||
def test_tickets_left_open_are_listed(self, client):
|
||||
self._state({'281331508': 'Open'})
|
||||
left = [{'ticket_id': '281331508', 'event_type': 'host_unreachable', 'target_name': 'pbs',
|
||||
'target_detail': '', 'severity': 'critical', 'first_seen': '2026-10-14T12:02:05Z',
|
||||
'cleared_at': '2026-11-04T22:12:36Z', 'events': 3}]
|
||||
gandalf.db.get_cleared_tickets.return_value = left
|
||||
assert client.get('/api/status', headers=AUTH).get_json()['stale_tickets'] == left
|
||||
gandalf.db.get_cleared_tickets.assert_called_with(['281331508'], older_than_hours=24)
|
||||
html = client.get('/', headers=AUTH).get_data(as_text=True)
|
||||
assert '#281331508' in html and 'TO FOLLOW UP' in html
|
||||
assert '<section class="g-section" id="followup">' in html
|
||||
|
||||
def test_out_of_date_list_flags_nothing(self, client):
|
||||
self._state({}, age_s=3 * 3600)
|
||||
gandalf.db.get_active_events.return_value = [self._event(1, '8')]
|
||||
body = client.get('/api/status', headers=AUTH).get_json()
|
||||
assert body['stale_tickets'] == [] and body['events'][0]['ticket_closed'] is False
|
||||
gandalf.db.get_cleared_tickets.assert_not_called()
|
||||
|
||||
def test_no_list_yet_hides_the_panel(self, client):
|
||||
html = client.get('/', headers=AUTH).get_data(as_text=True)
|
||||
assert '<section class="g-section" id="followup" hidden>' in html
|
||||
assert 'TO FOLLOW UP' not in html
|
||||
|
||||
|
||||
class TestTopology:
|
||||
def test_page_needs_auth(self, client):
|
||||
assert client.get('/topology').status_code == 401
|
||||
assert client.get('/api/topology').status_code == 401
|
||||
|
||||
def test_page_loads_the_drawings_first(self, client):
|
||||
html = client.get('/topology', headers=AUTH).get_data(as_text=True)
|
||||
assert 'id="tp-canvas"' in html
|
||||
assert html.index('faceplates.js') < html.index('fronts.js') < html.index('topology.js')
|
||||
|
||||
def test_api_returns_the_graph(self, client):
|
||||
gandalf._cutsheet_schema_ready = True
|
||||
with patch.object(gandalf.db, 'cutsheet_load', return_value={'items': [], 'cables': []}):
|
||||
data = client.get('/api/topology', headers=AUTH).get_json()
|
||||
assert {'nodes', 'links', 'warnings', 'updated'} <= set(data)
|
||||
names = {n['name'] for n in data['nodes']}
|
||||
assert {'large1', 'USW Flex', 'Internet'} <= names
|
||||
|
||||
def test_api_survives_a_cutsheet_failure(self, client):
|
||||
gandalf._cutsheet_schema_ready = True
|
||||
with patch.object(gandalf.db, 'cutsheet_load', side_effect=RuntimeError('db down')):
|
||||
assert client.get('/api/topology', headers=AUTH).status_code == 200
|
||||
|
||||
def test_suppressed_alerts_are_not_drawn(self, client):
|
||||
gandalf._cutsheet_schema_ready = True
|
||||
ev = {'id': 1, 'event_type': 'host_down', 'severity': 'critical', 'target_name': 'large1',
|
||||
'target_detail': '', 'description': ''}
|
||||
with patch.object(gandalf.db, 'cutsheet_load', return_value={'items': [], 'cables': []}), \
|
||||
patch.object(gandalf.db, 'get_active_events', return_value=[ev]), \
|
||||
patch.object(gandalf.db, 'check_suppressed', return_value=True):
|
||||
data = client.get('/api/topology', headers=AUTH).get_json()
|
||||
assert next(n for n in data['nodes'] if n['name'] == 'large1')['alert_count'] == 0
|
||||
|
||||
|
||||
class TestPowerFeedApi:
|
||||
LINK_STATS = json.dumps({'hosts': {}, 'unifi_switches': {}, 'unifi_devices': {
|
||||
'RPDU': {'outlets': [{'index': 7, 'name': 'Outlet 7', 'on': True, 'power_w': 48.0}]}}})
|
||||
SNAPSHOT = json.dumps({
|
||||
'hosts': {'large1': {'status': 'up', 'interfaces': {}}},
|
||||
'unifi': [{'name': 'RPDU', 'type': 'usw', 'model': 'USPPDUP', 'connected': True, 'mac': '', 'ip': ''}],
|
||||
})
|
||||
|
||||
def _put(self, client, path, body, headers=AUTH):
|
||||
state = dict(STATE, link_stats=self.LINK_STATS, network_snapshot=self.SNAPSHOT)
|
||||
gandalf._cutsheet_schema_ready = True
|
||||
with patch.object(gandalf.db, 'get_state', side_effect=lambda k, d=None: state.get(k, d)):
|
||||
return client.put(path, json=body, headers=headers)
|
||||
|
||||
def test_admin_assigns_an_outlet(self, client):
|
||||
resp = self._put(client, '/api/topology/power/RPDU/7', {'target': 'large1'})
|
||||
assert resp.status_code == 200
|
||||
gandalf.db.set_power_feed.assert_called_once_with('RPDU', 7, 'large1', 'jared')
|
||||
|
||||
def test_empty_means_nothing_and_null_means_automatic(self, client):
|
||||
assert self._put(client, '/api/topology/power/RPDU/7', {'target': ''}).status_code == 200
|
||||
assert self._put(client, '/api/topology/power/RPDU/7', {'target': None}).status_code == 200
|
||||
calls = [c.args for c in gandalf.db.set_power_feed.call_args_list]
|
||||
assert calls == [('RPDU', 7, '', 'jared'), ('RPDU', 7, None, 'jared')]
|
||||
|
||||
def test_needs_admin(self, client):
|
||||
resp = self._put(client, '/api/topology/power/RPDU/7', {'target': 'large1'},
|
||||
headers=dict(AUTH, **{'Remote-Groups': 'users'}))
|
||||
assert resp.status_code in (401, 403)
|
||||
gandalf.db.set_power_feed.assert_not_called()
|
||||
|
||||
def test_unknown_target_source_or_outlet(self, client):
|
||||
assert self._put(client, '/api/topology/power/RPDU/7', {'target': 'nope'}).status_code == 400
|
||||
assert self._put(client, '/api/topology/power/NOPE/7', {'target': 'large1'}).status_code == 404
|
||||
assert self._put(client, '/api/topology/power/RPDU/99', {'target': 'large1'}).status_code == 404
|
||||
gandalf.db.set_power_feed.assert_not_called()
|
||||
|
||||
def test_body_must_say_target(self, client):
|
||||
assert self._put(client, '/api/topology/power/RPDU/7', {}).status_code == 400
|
||||
assert self._put(client, '/api/topology/power/RPDU/7', {'target': 5}).status_code == 400
|
||||
|
||||
def test_must_be_json(self, client):
|
||||
gandalf._cutsheet_schema_ready = True
|
||||
resp = client.put('/api/topology/power/RPDU/7', data='target=large1', headers=AUTH,
|
||||
content_type='application/x-www-form-urlencoded')
|
||||
assert resp.status_code == 400
|
||||
|
||||
|
||||
class TestAttention:
|
||||
def test_needs_auth(self, client):
|
||||
assert client.get('/api/attention').status_code == 401
|
||||
|
||||
def test_gathers_every_page(self, client):
|
||||
gandalf._cutsheet_schema_ready = True
|
||||
ev = {'id': 1, 'event_type': 'host_down', 'severity': 'critical', 'target_name': 'large1',
|
||||
'target_detail': '', 'description': ''}
|
||||
with patch.object(gandalf.db, 'cutsheet_load', return_value={'items': [], 'cables': [], 'port_labels': []}), \
|
||||
patch.object(gandalf.db, 'get_active_events', return_value=[ev]), \
|
||||
patch.object(gandalf.db, 'get_power_feeds', return_value=[]), \
|
||||
patch.object(gandalf.db, 'cutsheet_racks', return_value=[]), \
|
||||
patch.object(gandalf.db, 'check_suppressed', return_value=False):
|
||||
data = client.get('/api/attention', headers=AUTH).get_json()
|
||||
assert set(data) == {'broken', 'tidy'}
|
||||
assert data['broken'][0]['text'] == '1 active alert (1 critical)'
|
||||
|
||||
def test_survives_a_cutsheet_failure(self, client):
|
||||
gandalf._cutsheet_schema_ready = True
|
||||
with patch.object(gandalf.db, 'cutsheet_load', side_effect=RuntimeError('db down')):
|
||||
resp = client.get('/api/attention', headers=AUTH)
|
||||
assert resp.status_code == 200
|
||||
assert set(resp.get_json()) == {'broken', 'tidy'}
|
||||
|
||||
def test_internet_quality_from_unifi(self, client):
|
||||
now = time.time()
|
||||
quality = {'periods': [{'ts': now - (12 - i) * 300, 'state': 'loss'} for i in range(12)],
|
||||
'downtime': [], 'latencies': {}, 'updated': now}
|
||||
state = {'wan_quality': json.dumps(quality), 'modem_stats': json.dumps({'reachable': True})}
|
||||
with patch.object(gandalf.db, 'get_state', side_effect=lambda k, d=None: state.get(k, d)), \
|
||||
patch.object(gandalf.db, 'get_modem_history', return_value=[]), \
|
||||
patch.object(gandalf.db, 'cutsheet_load', side_effect=RuntimeError('db down')):
|
||||
data = client.get('/api/attention', headers=AUTH).get_json()
|
||||
modem = client.get('/api/modem', headers=AUTH).get_json()
|
||||
assert data['broken'][0]['text'] == 'Internet: packet loss in 12 of the last 12 five-minute periods'
|
||||
assert len(modem['wan_quality']['periods']) == 12
|
||||
|
||||
def test_dashboard_has_the_list_and_says_what_gandalf_stands_for(self, client):
|
||||
html = client.get('/', headers=AUTH).get_data(as_text=True)
|
||||
assert 'id="attention-body"' in html
|
||||
assert 'Global Advanced Network Detection And Link Facilitator' in html
|
||||
|
||||
|
||||
class TestCalmDashboard:
|
||||
def test_unused_nics_fold_into_one_line(self, client):
|
||||
snap = json.dumps({'hosts': {'large1': {'ip': '10.0.0.2', 'status': 'up', 'source': 'prometheus',
|
||||
'interfaces': {'eth0': 'up', 'eth1': 'unused', 'eth2': 'unused'}}},
|
||||
'unifi': []})
|
||||
state = dict(STATE, network_snapshot=snap)
|
||||
with patch.object(gandalf.db, 'get_state', side_effect=lambda k, d=None: state.get(k, d)):
|
||||
html = client.get('/', headers=AUTH).get_data(as_text=True)
|
||||
assert '>eth0<' in html and '>eth1<' not in html
|
||||
assert '+2 unused' in html
|
||||
|
||||
def test_source_tag_only_for_hosts_without_node_exporter(self, client):
|
||||
snap = json.dumps({'hosts': {
|
||||
'large1': {'ip': '10.0.0.2', 'status': 'up', 'source': 'prometheus', 'interfaces': {'eth0': 'up'}},
|
||||
'pbs': {'ip': '10.0.0.3', 'status': 'up', 'source': 'ping', 'interfaces': {}}}, 'unifi': []})
|
||||
state = dict(STATE, network_snapshot=snap)
|
||||
with patch.object(gandalf.db, 'get_state', side_effect=lambda k, d=None: state.get(k, d)):
|
||||
html = client.get('/', headers=AUTH).get_data(as_text=True)
|
||||
assert 'source-prometheus' not in html
|
||||
assert '<span class="host-source source-ping">ping</span>' in html
|
||||
|
||||
def test_alert_table_turns_into_cards_on_phones(self, client):
|
||||
ev = {'id': 1, 'event_type': 'host_down', 'severity': 'critical', 'target_name': 'pbs',
|
||||
'target_detail': '', 'description': 'pbs is down', 'consecutive_failures': 3,
|
||||
'first_seen': '2026-11-15 01:00:00', 'last_seen': '2026-11-15 02:00:00'}
|
||||
with patch.object(gandalf.db, 'get_active_events', return_value=[ev]):
|
||||
html = client.get('/', headers=AUTH).get_data(as_text=True)
|
||||
assert 'class="lt-table lt-table-responsive" id="events-table"' in html
|
||||
assert 'data-label="Target"><strong>pbs</strong>' in html
|
||||
|
||||
def test_resolved_alerts_are_folded(self, client):
|
||||
ev = {'target_name': 'large1', 'target_detail': '', 'severity': 'warning', 'event_type': 'host_down',
|
||||
'first_seen': '2026-11-15 01:00:00 UTC', 'resolved_at': '2026-11-15 02:00:00 UTC'}
|
||||
with patch.object(gandalf.db, 'get_recent_resolved', return_value=[ev]):
|
||||
html = client.get('/', headers=AUTH).get_data(as_text=True)
|
||||
assert '<details class="g-section resolved-fold">' in html
|
||||
|
||||
|
||||
class TestModemRestart:
|
||||
CFG = dict(CONFIG, modem={'url': 'http://192.0.2.254', 'access_code': 'secret'},
|
||||
uptime_kuma={'url': 'http://kuma.test', 'username': 'u', 'password': 'p', 'maintenance_id': 7})
|
||||
|
||||
def _post(self, client, body=None, headers=AUTH, cfg=None, kuma_error=None, restart=None):
|
||||
admin = MagicMock()
|
||||
if isinstance(restart, Exception):
|
||||
admin.restart.side_effect = restart
|
||||
else:
|
||||
admin.restart.return_value = restart or 'accepted'
|
||||
with patch.object(gandalf, '_cfg', cfg or self.CFG), \
|
||||
patch.object(gandalf.kuma, 'set_maintenance', side_effect=kuma_error) as km, \
|
||||
patch.object(gandalf.modem_api, 'ModemAdmin', return_value=admin):
|
||||
gandalf.db.create_suppression.return_value = 42
|
||||
resp = client.post('/api/modem/restart', json=body if body is not None else {'confirm': True},
|
||||
headers=headers)
|
||||
return resp, km, admin
|
||||
|
||||
def test_admin_only(self, client):
|
||||
resp, _, admin = self._post(client, headers=USER)
|
||||
assert resp.status_code == 403 and not admin.restart.called
|
||||
|
||||
def test_needs_confirm(self, client):
|
||||
resp, km, admin = self._post(client, body={})
|
||||
assert resp.status_code == 400 and not km.called and not admin.restart.called
|
||||
|
||||
def test_needs_the_access_code(self, client):
|
||||
resp, _, admin = self._post(client, cfg=dict(CONFIG, modem={'url': 'http://192.0.2.254'}))
|
||||
assert resp.status_code == 400 and 'access_code' in resp.get_json()['error']
|
||||
|
||||
def test_silences_then_restarts(self, client):
|
||||
resp, km, admin = self._post(client)
|
||||
assert resp.status_code == 200
|
||||
assert resp.get_json() == {'ok': True, 'result': 'accepted', 'kuma': True, 'suppression_id': 42}
|
||||
km.assert_called_once_with(self.CFG['uptime_kuma'], True)
|
||||
args = gandalf.db.create_suppression.call_args.args
|
||||
assert args[:3] == ('all', '', '') and args[4] == 'jared' and args[5] == gandalf.MODEM_RESTART_SILENCE_MIN
|
||||
admin.restart.assert_called_once_with()
|
||||
key, state = gandalf.db.set_state.call_args.args
|
||||
assert key == 'modem_restart' and state['suppression_id'] == 42 and state['kuma'] is True
|
||||
|
||||
def test_kuma_failure_stops_unless_accepted(self, client):
|
||||
resp, _, admin = self._post(client, kuma_error=gandalf.kuma.KumaError('login refused'))
|
||||
assert resp.status_code == 502 and resp.get_json()['kuma_failed'] and not admin.restart.called
|
||||
resp, _, admin = self._post(client, body={'confirm': True, 'without_kuma': True},
|
||||
kuma_error=gandalf.kuma.KumaError('login refused'))
|
||||
assert resp.status_code == 200 and resp.get_json()['kuma'] is False and admin.restart.called
|
||||
|
||||
def test_failed_restart_undoes_the_silence(self, client):
|
||||
resp, km, _ = self._post(client, restart=gandalf.modem_api.ModemUnreachable('timeout'))
|
||||
assert resp.status_code == 502
|
||||
gandalf.db.deactivate_suppression.assert_called_once_with(42)
|
||||
assert km.call_args_list[-1].args == (self.CFG['uptime_kuma'], False)
|
||||
|
||||
def test_one_at_a_time(self, client):
|
||||
pending = json.dumps({'at': time.time() - 60, 'finished_at': None})
|
||||
state = {'modem_restart': pending}
|
||||
with patch.object(gandalf.db, 'get_state', side_effect=lambda k, d=None: state.get(k, d)):
|
||||
resp, _, admin = self._post(client)
|
||||
assert resp.status_code == 409 and not admin.restart.called
|
||||
@@ -0,0 +1,183 @@
|
||||
"""The dashboard's "Needs attention" list (attention.py)."""
|
||||
import attention
|
||||
|
||||
|
||||
def _alert(target, severity='critical', **kw):
|
||||
return dict({'target_name': target, 'severity': severity, 'is_suppressed': False}, **kw)
|
||||
|
||||
|
||||
def _outlet(index, on=True, target=None, power_w=10.0, match=None):
|
||||
return {'index': index, 'on': on, 'target': target, 'power_w': power_w,
|
||||
'match': match or ('name' if target else 'none')}
|
||||
|
||||
|
||||
class TestAlerts:
|
||||
def test_one_line_for_all_alerts_with_the_targets(self):
|
||||
out = attention.build([_alert('pbs'), _alert('24RJ45-POE', 'warning')], [], None)
|
||||
[line] = out['broken']
|
||||
assert line['text'] == '2 active alerts (1 critical)'
|
||||
assert line['severity'] == 'bad'
|
||||
assert line['detail'] == '24RJ45-POE, pbs'
|
||||
assert line['href'] == '#events-table-wrap'
|
||||
|
||||
def test_suppressed_and_info_alerts_are_left_out(self):
|
||||
events = [_alert('pbs', is_suppressed=True), _alert('large1', 'info')]
|
||||
assert attention.build(events, [], None)['broken'] == []
|
||||
|
||||
def test_warnings_only_is_amber(self):
|
||||
[line] = attention.build([_alert('x', 'warning')], [], None)['broken']
|
||||
assert line['severity'] == 'warn' and line['text'] == '1 active alert'
|
||||
|
||||
|
||||
class TestPower:
|
||||
def test_frozen_readings_and_an_off_outlet_feeding_a_device(self):
|
||||
power = [{'node': 'RPDU', 'stale_since': '2026-11-15 05:26:54 UTC',
|
||||
'outlets': [_outlet(19, on=False, target='pbs'), _outlet(3, on=False)]}]
|
||||
broken = attention.build([], power, None)['broken']
|
||||
assert [b['text'] for b in broken] == ['RPDU outlet 19 is off, and it feeds pbs',
|
||||
'RPDU: outlet watts are frozen']
|
||||
|
||||
def test_powered_outlets_with_nothing_assigned(self):
|
||||
power = [{'node': 'RPDU', 'outlets': [
|
||||
_outlet(1, target='large1'), _outlet(2, power_w=40), _outlet(3, power_w=1),
|
||||
_outlet(4, power_w=40, match='cleared'), _outlet(5, on=False, power_w=0)]}]
|
||||
[line] = attention.build([], power, None)['tidy']
|
||||
assert line['text'] == '1 powered outlet with no device assigned'
|
||||
assert line['detail'] == 'RPDU 2'
|
||||
|
||||
|
||||
class TestCutsheet:
|
||||
VIEW = {
|
||||
'cables': [{'id': 1, 'label': 'C01', 'status': 'installed', 'problem': True},
|
||||
{'id': 2, 'label': 'C02', 'status': 'retired', 'problem': True},
|
||||
{'id': 3, 'label': 'C03', 'status': 'installed', 'problem': False}],
|
||||
'suggestions': [{}, {}, {}],
|
||||
'port_names': [{'kind': 'wrong', 'switch': 'POE', 'port_idx': 11, 'port_name': 'Large1 Management'},
|
||||
{'kind': 'empty', 'switch': 'POE', 'port_idx': 20, 'port_name': 'WAP'},
|
||||
{'kind': 'unnamed', 'switch': 'POE', 'port_idx': 4, 'port_name': 'Port 4'}],
|
||||
'labels': {'cables': [{}, {}], 'ports': [{}]},
|
||||
}
|
||||
|
||||
def test_every_cutsheet_todo(self):
|
||||
out = attention.build([], [], self.VIEW)
|
||||
assert [b['text'] for b in out['broken']] == ['1 cable not where the cutsheet says']
|
||||
assert out['broken'][0]['detail'] == 'C01'
|
||||
assert out['broken'][0]['href'].startswith('/cutsheet?problems=1')
|
||||
tidy = {t['text']: t for t in out['tidy']}
|
||||
assert set(tidy) == {'1 UniFi port name pointing at the wrong device', '1 named port with nothing plugged in',
|
||||
'3 live links not on the cutsheet', '3 labels to print and stick on'}
|
||||
assert tidy['1 UniFi port name pointing at the wrong device']['detail'] == 'POE port 11 "Large1 Management"'
|
||||
# Worst first
|
||||
assert out['tidy'][0]['severity'] == 'warn'
|
||||
|
||||
def test_unnamed_ports_alone_are_not_worth_a_line(self):
|
||||
view = {'port_names': [{'kind': 'unnamed', 'switch': 'POE', 'port_idx': 4, 'port_name': 'Port 4'}]}
|
||||
assert attention.build([], [], view) == {'broken': [], 'tidy': []}
|
||||
|
||||
|
||||
class TestRack:
|
||||
def test_overlaps_and_items_outside_the_rack(self):
|
||||
racks = {'Rack 1': {'overlaps': [{'name': 'NAS', 'units': 'U5-6', 'with': ['storage-01']}],
|
||||
'outside': [{'name': 'Shelf', 'units': 'U43'}]}}
|
||||
texts = [t['text'] for t in attention.build([], [], None, racks)['tidy']]
|
||||
assert texts == ['NAS overlaps storage-01 at U5-6', 'Shelf at U43 is outside Rack 1']
|
||||
|
||||
def test_nothing_to_report(self):
|
||||
assert attention.build([], [], {}, {}) == {'broken': [], 'tidy': []}
|
||||
|
||||
|
||||
NOW = 1_000_000.0
|
||||
|
||||
|
||||
def _quality(states, downtime=(), latencies=None, updated=NOW):
|
||||
"""states: newest last, one per 5 minutes ending at NOW."""
|
||||
n = len(states)
|
||||
return {'periods': [{'ts': NOW - (n - i) * 300, 'state': s} for i, s in enumerate(states)],
|
||||
'downtime': [{'ts': NOW - ago, 'seconds': s} for ago, s in downtime],
|
||||
'latencies': latencies or {}, 'updated': updated}
|
||||
|
||||
|
||||
def _wan(q):
|
||||
return [e for e in attention.build([], [], None, wan_quality=q, now=NOW)['broken']
|
||||
if e['text'].startswith('Internet')]
|
||||
|
||||
|
||||
class TestWan:
|
||||
def test_healthy_says_nothing(self):
|
||||
assert _wan(_quality(['ok'] * 288)) == []
|
||||
|
||||
def test_latency_in_the_last_hour(self):
|
||||
[e] = _wan(_quality(['ok'] * 276 + ['latency', 'ok'] * 3 + ['latency'] * 3 + ['ok'] * 3,
|
||||
latencies={'google': 26, 'cloudflare': 12}))
|
||||
assert e['severity'] == 'warn' and e['href'] == '#modem-section'
|
||||
assert e['text'] == 'Internet: high latency in 6 of the last 12 five-minute periods'
|
||||
assert 'UniFi flagged 6 of the last 288' in e['detail']
|
||||
assert 'Now: cloudflare 12 ms, google 26 ms' in e['detail']
|
||||
|
||||
def test_a_couple_of_slow_periods_are_not_worth_a_line(self):
|
||||
assert _wan(_quality(['ok'] * 10 + ['latency'] * 2)) == []
|
||||
|
||||
def test_old_trouble_has_cleared(self):
|
||||
assert _wan(_quality(['latency'] * 100 + ['ok'] * 12)) == []
|
||||
|
||||
def test_packet_loss_is_broken(self):
|
||||
[e] = _wan(_quality(['ok'] * 9 + ['loss', 'latency', 'down']))
|
||||
assert e['severity'] == 'bad'
|
||||
assert e['text'] == 'Internet: packet loss in 2 of the last 12 five-minute periods'
|
||||
|
||||
def test_a_drop_in_the_last_hour(self):
|
||||
[e] = _wan(_quality(['ok'] * 12, downtime=[(900, 90), (7200, 30)]))
|
||||
assert e['text'] == 'Internet dropped for 90 s, 15 min ago'
|
||||
|
||||
def test_several_drops(self):
|
||||
[e] = _wan(_quality(['ok'] * 12, downtime=[(900, 90), (1800, 30)]))
|
||||
assert e['text'] == 'Internet dropped 2 times in the last hour, 120 s in all'
|
||||
|
||||
def test_stale_copy_is_ignored(self):
|
||||
assert _wan(_quality(['loss'] * 12, updated=NOW - 3600)) == []
|
||||
|
||||
def test_none_is_fine(self):
|
||||
assert _wan(None) == [] and _wan({}) == []
|
||||
|
||||
def test_internet_comes_before_alerts_of_the_same_severity(self):
|
||||
out = attention.build([_alert('x', 'warning')], [], None,
|
||||
wan_quality=_quality(['latency'] * 12), now=NOW)['broken']
|
||||
assert out[0]['text'].startswith('Internet')
|
||||
|
||||
|
||||
class TestModemChecks:
|
||||
def _broken(self, checks, quality=None):
|
||||
return attention.build([], [], None, wan_quality=quality, now=NOW, modem_checks=checks)
|
||||
|
||||
def test_gateway_ping_explains_the_latency(self):
|
||||
checks = {'ping': {'at': NOW - 120, 'avg_ms': 20.4, 'loss_pct': 0, 'ours_ms': 1043, 'verdict': 'gateway'}}
|
||||
[e] = self._broken(checks, _quality(['latency'] * 12))['broken']
|
||||
assert ("Modem's own ping 2 min ago: 20 ms; ours through it 1043 ms, "
|
||||
'so the delay is in the modem, or between it and the router.') in e['detail']
|
||||
|
||||
def test_upstream_verdict(self):
|
||||
checks = {'ping': {'at': NOW - 60, 'avg_ms': 900.0, 'loss_pct': 20, 'ours_ms': 1000, 'verdict': 'upstream'}}
|
||||
[e] = self._broken(checks, _quality(['latency'] * 12))['broken']
|
||||
assert ("900 ms, 20% lost; ours through it 1000 ms, "
|
||||
"so the delay is past the modem, on the provider's side") in e['detail']
|
||||
|
||||
def test_old_ping_is_left_out(self):
|
||||
checks = {'ping': {'at': NOW - 7200, 'avg_ms': 20.0, 'verdict': 'clear'}}
|
||||
[e] = self._broken(checks, _quality(['latency'] * 12))['broken']
|
||||
assert "Modem's own ping" not in e['detail']
|
||||
|
||||
def test_nat_nearly_full(self):
|
||||
[e] = self._broken({'nat': {'in_use': 30000, 'available': 32767}})['broken']
|
||||
assert e['text'] == 'Modem NAT table 92% full' and e['severity'] == 'warn'
|
||||
assert '30,000 of 32,767' in e['detail']
|
||||
|
||||
def test_nat_normal_says_nothing(self):
|
||||
out = self._broken({'nat': {'in_use': 2858, 'available': 32767}})
|
||||
assert out == {'broken': [], 'tidy': []}
|
||||
|
||||
def test_login_failure_is_housekeeping(self):
|
||||
[e] = self._broken({'error': {'login': True, 'message': 'refused', 'at': NOW}})['tidy']
|
||||
assert e['text'].startswith('Modem login failed')
|
||||
|
||||
def test_other_errors_stay_quiet(self):
|
||||
assert self._broken({'error': {'login': False, 'message': 'timeout', 'at': NOW}})['tidy'] == []
|
||||
@@ -0,0 +1,394 @@
|
||||
"""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',
|
||||
'usw-pro-max-24-poe', 'usw-pro-max-48-poe', 'zimaboard-832', 'zimaboard-832-cx3',
|
||||
'resting', 'uacc-brush-1u', 'sliger-cx4712-red', 'sliger-cx4712-white',
|
||||
'sliger-cx4712-blue'} <= set(cs.CHASSIS)
|
||||
|
||||
|
||||
class TestFacingAndSlots:
|
||||
def test_facing_and_slot_validation(self):
|
||||
shelf = {'S': {'name': 'S', 'kind': 'shelf'}}
|
||||
assert cs.validate_item({'name': 'p', 'facing': 'rear'})['facing'] == 'rear'
|
||||
assert cs.validate_item({'name': 'p'})['facing'] == 'front'
|
||||
assert cs.validate_item({'name': 'z', 'shelf': 'S', 'slot': '2'}, shelf)['slot'] == 2
|
||||
with pytest.raises(cs.ValidationError):
|
||||
cs.validate_item({'name': 'p', 'facing': 'up'})
|
||||
with pytest.raises(cs.ValidationError):
|
||||
cs.validate_item({'name': 'p', 'slot': 1}) # a position needs a shelf
|
||||
|
||||
def test_rear_posts_facing_front_are_seen_from_the_front(self):
|
||||
items = [{'id': 1, 'name': 'pdu', 'kind': 'device', 'rack_u': 24, 'rack_height': 2, 'mount': 'rear'},
|
||||
{'id': 2, 'name': 'udm', 'kind': 'device', 'rack_u': 24, 'rack_height': 1}]
|
||||
assert [i['name'] for i in cs.rack_layout(items, 25, 'front')['placed']] == ['udm']
|
||||
behind = cs.rack_layout(items, 25, 'behind')['placed']
|
||||
assert [(i['name'], i['through']) for i in behind] == [('pdu', False)]
|
||||
assert [(i['name'], i['through']) for i in cs.rack_layout(items, 25, 'rear')['placed']] == [('pdu', True)]
|
||||
@@ -0,0 +1,86 @@
|
||||
"""Tests for db.py query helpers that do work beyond the SQL: the connection is faked."""
|
||||
import os
|
||||
import sys
|
||||
from contextlib import contextmanager
|
||||
from datetime import datetime, timedelta
|
||||
from unittest.mock import MagicMock, patch
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
|
||||
|
||||
import db # noqa: E402
|
||||
|
||||
NOW = datetime(2026, 11, 14, 12, 0, 0)
|
||||
|
||||
|
||||
def _fake_conn(rows):
|
||||
cur = MagicMock()
|
||||
cur.fetchall.return_value = rows
|
||||
cur.fetchone.return_value = {'now': NOW}
|
||||
conn = MagicMock()
|
||||
conn.cursor.return_value.__enter__.return_value = cur
|
||||
|
||||
@contextmanager
|
||||
def get_conn():
|
||||
yield conn
|
||||
return patch.object(db, 'get_conn', get_conn), cur
|
||||
|
||||
|
||||
def _event(tid, hours_ago_first, hours_ago_resolved, etype='host_unreachable', target='pbs'):
|
||||
return {
|
||||
'ticket_id': tid, 'event_type': etype, 'target_name': target, 'target_detail': '',
|
||||
'severity': 'critical', 'first_seen': NOW - timedelta(hours=hours_ago_first),
|
||||
'resolved_at': None if hours_ago_resolved is None else NOW - timedelta(hours=hours_ago_resolved),
|
||||
}
|
||||
|
||||
|
||||
class TestGetClearedTickets:
|
||||
def test_no_ids_skips_the_query(self):
|
||||
patcher, cur = _fake_conn([])
|
||||
with patcher:
|
||||
assert db.get_cleared_tickets([]) == []
|
||||
cur.execute.assert_not_called()
|
||||
|
||||
def test_only_tickets_whose_every_alert_cleared_long_enough_ago(self):
|
||||
rows = [
|
||||
_event('1', 300, 250), _event('1', 100, 48), # two outages, both long cleared
|
||||
_event('2', 50, 40), _event('2', 5, None), # still active
|
||||
_event('3', 10, 2), # cleared too recently
|
||||
]
|
||||
patcher, cur = _fake_conn(rows)
|
||||
with patcher:
|
||||
out = db.get_cleared_tickets(['3', '1', '2', '1'], older_than_hours=24)
|
||||
assert [r['ticket_id'] for r in out] == ['1']
|
||||
assert out[0]['events'] == 2
|
||||
assert out[0]['cleared_at'] == (NOW - timedelta(hours=48)).isoformat() + 'Z'
|
||||
assert out[0]['first_seen'] == (NOW - timedelta(hours=300)).isoformat() + 'Z'
|
||||
assert cur.execute.call_args_list[0].args[1] == ['1', '2', '3']
|
||||
|
||||
def test_newest_clearance_first(self):
|
||||
rows = [_event('1', 400, 300), _event('2', 100, 30, target='micro1')]
|
||||
patcher, _ = _fake_conn(rows)
|
||||
with patcher:
|
||||
out = db.get_cleared_tickets(['1', '2'])
|
||||
assert [r['ticket_id'] for r in out] == ['2', '1']
|
||||
assert out[0]['target_name'] == 'micro1'
|
||||
|
||||
|
||||
class TestPowerFeeds:
|
||||
def test_none_goes_back_to_automatic(self):
|
||||
patcher, cur = _fake_conn([])
|
||||
with patcher:
|
||||
db.set_power_feed('RPDU', 7, None, 'jared')
|
||||
sql, args = cur.execute.call_args.args
|
||||
assert sql.startswith('DELETE FROM power_feeds') and args == ('RPDU', 7)
|
||||
|
||||
def test_empty_target_is_saved_as_nothing(self):
|
||||
patcher, cur = _fake_conn([])
|
||||
with patcher:
|
||||
db.set_power_feed('RPDU', 7, '', 'jared')
|
||||
sql, args = cur.execute.call_args.args
|
||||
assert 'INSERT INTO power_feeds' in sql and args == ('RPDU', 7, '', 'jared')
|
||||
|
||||
def test_rows_come_back_with_iso_times(self):
|
||||
patcher, _ = _fake_conn([{'source': 'RPDU', 'outlet': 7, 'target': 'large1', 'updated_by': 'jared',
|
||||
'updated_at': NOW}])
|
||||
with patcher:
|
||||
assert db.get_power_feeds()[0]['updated_at'] == '2026-11-14T12:00:00Z'
|
||||
@@ -0,0 +1,208 @@
|
||||
"""Tests for devices.py: the inventory behind search and device pages."""
|
||||
import os
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
|
||||
|
||||
import devices # noqa: E402
|
||||
|
||||
SNAPSHOT = {
|
||||
'hosts': {
|
||||
'large1': {'ip': '10.0.0.2', 'status': 'degraded', 'source': 'prometheus',
|
||||
'interfaces': {'eth0': 'up', 'eth1': 'down'}},
|
||||
},
|
||||
'unifi': [
|
||||
{'name': 'Dream Machine Pro', 'type': 'udm', 'model': 'UDMPRO', 'ip': '203.0.113.5',
|
||||
'mac': 'aa:bb:cc:dd:ee:ff', 'connected': True},
|
||||
{'name': '24RJ45-POE', 'type': 'usw', 'model': 'US24PRO', 'ip': '10.0.0.40',
|
||||
'mac': '11:22:33:44:55:66', 'connected': False},
|
||||
{'name': 'RPDU', 'type': 'usw', 'model': 'USPPDUP', 'ip': '10.0.0.50', 'mac': '', 'connected': True},
|
||||
{'name': 'AP', 'type': 'uap', 'model': 'UAL6', 'ip': '10.0.0.60', 'mac': '', 'connected': True},
|
||||
],
|
||||
}
|
||||
LINKS = {
|
||||
'hosts': {'large1': {'eth0': {'host_ip': '10.0.0.2', 'speed_mbps': 1000}}},
|
||||
'unifi_switches': {
|
||||
'24RJ45-POE': {'ip': '10.0.0.40', 'model': 'US24PRO', 'ports': {
|
||||
'Port 3': {'port_idx': 3, 'up': True, 'speed_mbps': 1000,
|
||||
'lldp': {'system_name': 'large1', 'port_id': 'eth0'}},
|
||||
'Port 4': {'port_idx': 4, 'up': False, 'lldp': None},
|
||||
}},
|
||||
},
|
||||
'unifi_devices': {'Dream Machine Pro': {'firmware': '6.0.17', 'wan': {'wan1': {'up': True}}}},
|
||||
'updated': '2026-11-05 00:00:00 UTC',
|
||||
}
|
||||
MODEM = {'name': 'att-modem', 'reachable': True, 'lan_ip': '192.168.1.254', 'wan_ip': '203.0.113.5',
|
||||
'model': 'BGW320-505', 'wan_problems': []}
|
||||
|
||||
|
||||
def index():
|
||||
return {d['name']: d for d in devices.build_index(SNAPSHOT, LINKS, MODEM)}
|
||||
|
||||
|
||||
class TestKinds:
|
||||
def test_kinds(self):
|
||||
i = index()
|
||||
assert i['large1']['kind'] == 'host'
|
||||
assert i['Dream Machine Pro']['kind'] == 'router'
|
||||
assert i['24RJ45-POE']['kind'] == 'switch'
|
||||
assert i['AP']['kind'] == 'ap'
|
||||
assert i['att-modem']['kind'] == 'modem'
|
||||
|
||||
def test_pdu_model_beats_reported_type(self):
|
||||
assert index()['RPDU']['kind'] == 'pdu'
|
||||
|
||||
|
||||
class TestSearchText:
|
||||
def test_finds_host_by_ip_and_interface(self):
|
||||
s = index()['large1']['search']
|
||||
assert '10.0.0.2' in s and 'eth1' in s
|
||||
|
||||
def test_mac_with_and_without_separators(self):
|
||||
s = index()['Dream Machine Pro']['search']
|
||||
assert 'aa:bb:cc:dd:ee:ff' in s and 'aabbccddeeff' in s
|
||||
|
||||
def test_switch_found_by_port_neighbor(self):
|
||||
assert 'large1' in index()['24RJ45-POE']['search']
|
||||
|
||||
def test_modem_found_by_either_address_or_word(self):
|
||||
s = index()['att-modem']['search']
|
||||
assert '192.168.1.254' in s and '203.0.113.5' in s and 'fiber' in s
|
||||
|
||||
|
||||
class TestStatus:
|
||||
def test_offline_unifi_device_is_down(self):
|
||||
assert index()['24RJ45-POE']['status'] == 'down'
|
||||
|
||||
def test_modem_status(self):
|
||||
def status(**kw):
|
||||
return {d['name']: d for d in devices.build_index({}, {}, dict(MODEM, **kw))}['att-modem']['status']
|
||||
assert status() == 'up'
|
||||
assert status(wan_problems=['optical WAN is Down']) == 'down'
|
||||
assert status(reachable=False) == 'unknown'
|
||||
|
||||
|
||||
class TestPartialData:
|
||||
def test_empty_state(self):
|
||||
assert devices.build_index({}, {}, {}) == []
|
||||
assert devices.build_index(None, None, None) == []
|
||||
|
||||
def test_switch_known_only_from_link_stats(self):
|
||||
d = {x['name']: x for x in devices.build_index({}, LINKS, None)}['24RJ45-POE']
|
||||
assert d['status'] == 'unknown' and d['kind'] == 'switch'
|
||||
|
||||
|
||||
class TestUnconfiguredHosts:
|
||||
LINKS = {'hosts': {'10.0.0.77': {'eth0': {'host_ip': '10.0.0.77', 'speed_mbps': 1000}}}}
|
||||
|
||||
def test_host_only_in_link_stats_is_kept(self):
|
||||
d = {x['name']: x for x in devices.build_index({}, self.LINKS, None)}['10.0.0.77']
|
||||
assert d['kind'] == 'host' and d['status'] == 'unknown' and d['ip'] == '10.0.0.77'
|
||||
|
||||
def test_its_interfaces_are_available(self):
|
||||
d = devices.device_detail('10.0.0.77', {}, self.LINKS, None)
|
||||
assert d['interfaces']['eth0']['speed_mbps'] == 1000
|
||||
|
||||
|
||||
class TestDetail:
|
||||
def test_unknown_device(self):
|
||||
assert devices.device_detail('nope', SNAPSHOT, LINKS, MODEM) is None
|
||||
|
||||
def test_host_merges_state_and_stats(self):
|
||||
d = devices.device_detail('large1', SNAPSHOT, LINKS, MODEM)
|
||||
assert d['interfaces']['eth0'] == {'state': 'up', 'host_ip': '10.0.0.2', 'speed_mbps': 1000}
|
||||
assert d['interfaces']['eth1'] == {'state': 'down'}
|
||||
assert 'search' not in d
|
||||
|
||||
def test_host_shows_switch_port_from_lldp(self):
|
||||
up = devices.device_detail('large1', SNAPSHOT, LINKS, MODEM)['uplinks']
|
||||
assert up == [{'switch': '24RJ45-POE', 'port': 'Port 3', 'port_idx': 3,
|
||||
'host_interface': 'eth0', 'up': True, 'speed_mbps': 1000}]
|
||||
|
||||
def test_switch_has_ports(self):
|
||||
assert set(devices.device_detail('24RJ45-POE', SNAPSHOT, LINKS, MODEM)['ports']) == {'Port 3', 'Port 4'}
|
||||
|
||||
def test_switch_gets_only_its_lldp_neighbors_for_the_path_check(self):
|
||||
links = dict(LINKS, hosts=dict(LINKS['hosts'], other={'eth9': {}}))
|
||||
d = devices.device_detail('24RJ45-POE', SNAPSHOT, links, MODEM)
|
||||
assert set(d['neighbor_hosts']) == {'large1'}
|
||||
assert 'eth0' in d['neighbor_hosts']['large1']
|
||||
|
||||
def test_router_has_info_even_without_port_data(self):
|
||||
d = devices.device_detail('Dream Machine Pro', SNAPSHOT, LINKS, MODEM)
|
||||
assert d['info']['firmware'] == '6.0.17' and d['ports'] == {}
|
||||
|
||||
|
||||
class TestLldpResolution:
|
||||
HOSTS = {'9c:6b:00:8a:17:e6': ('micro1', 'enp1s0')}
|
||||
DEVS = {'78:45:58:b1:bd:3a': '24RJ45-POE'}
|
||||
IPS = {'10.0.0.9': 'storage-01'}
|
||||
|
||||
def resolve(self, **lldp):
|
||||
sw = {'s': {'ports': {'p': {'lldp': lldp}}}}
|
||||
devices.resolve_lldp_neighbors(sw, self.HOSTS, self.DEVS, self.IPS)
|
||||
return sw['s']['ports']['p']['lldp']
|
||||
|
||||
def test_port_mac_gives_host_and_interface(self):
|
||||
got = self.resolve(chassis_id='aa:aa:aa:aa:aa:aa', port_id='9C:6B:00:8A:17:E6')
|
||||
assert (got['system_name'], got['port_id']) == ('micro1', 'enp1s0')
|
||||
|
||||
def test_chassis_mac_keeps_a_named_port(self):
|
||||
got = self.resolve(chassis_id='9c:6b:00:8a:17:e6', port_id='enp9s0')
|
||||
assert (got['system_name'], got['port_id']) == ('micro1', 'enp9s0')
|
||||
|
||||
def test_unifi_device_by_chassis(self):
|
||||
got = self.resolve(chassis_id='78:45:58:b1:bd:3a', port_id='Port 26')
|
||||
assert (got['system_name'], got['port_id']) == ('24RJ45-POE', 'Port 26')
|
||||
|
||||
def test_management_ip_fallback(self):
|
||||
got = self.resolve(chassis_id='aa:aa:aa:aa:aa:aa', port_id='x', mgmt_ips=['10.0.0.9'])
|
||||
assert got['system_name'] == 'storage-01'
|
||||
|
||||
def test_unknown_neighbor_stays_unnamed(self):
|
||||
got = self.resolve(chassis_id='aa:aa:aa:aa:aa:aa', port_id='aa:aa:aa:aa:aa:ab')
|
||||
assert got['system_name'] == ''
|
||||
|
||||
def test_a_reported_name_is_kept(self):
|
||||
got = self.resolve(system_name='lldp-name', chassis_id='78:45:58:b1:bd:3a', port_id='x')
|
||||
assert got['system_name'] == 'lldp-name'
|
||||
|
||||
def test_port_without_lldp_is_left_alone(self):
|
||||
sw = {'s': {'ports': {'p': {'lldp': None}}}}
|
||||
devices.resolve_lldp_neighbors(sw, self.HOSTS, self.DEVS, self.IPS)
|
||||
assert sw['s']['ports']['p']['lldp'] is None
|
||||
|
||||
|
||||
class TestClientLocations:
|
||||
HOSTS = {'aa:aa:aa:aa:aa:01': ('large1', 'enp35s0')}
|
||||
DEVS = {'bb:bb:bb:bb:bb:01': 'sw'}
|
||||
|
||||
def apply(self, port, sw_port=10):
|
||||
switches = {'sw': {'ports': {'Port 10': dict({'port_idx': 10}, **port)}}}
|
||||
client = {'mac': 'AA:AA:AA:AA:AA:01', 'sw_mac': 'bb:bb:bb:bb:bb:01', 'sw_port': sw_port}
|
||||
devices.apply_client_locations(switches, [client], self.HOSTS, self.DEVS)
|
||||
return switches['sw']['ports']['Port 10']['lldp']
|
||||
|
||||
def test_server_without_lldp_is_located(self):
|
||||
got = self.apply({'lldp': None})
|
||||
assert (got['system_name'], got['port_id'], got['source']) == ('large1', 'enp35s0', 'unifi-clients')
|
||||
|
||||
def test_uplink_port_is_skipped(self):
|
||||
assert self.apply({'lldp': None, 'is_uplink': True}) is None
|
||||
|
||||
def test_named_lldp_neighbor_is_kept(self):
|
||||
assert self.apply({'lldp': {'system_name': 'other'}})['system_name'] == 'other'
|
||||
|
||||
def test_unnamed_lldp_entry_is_replaced(self):
|
||||
assert self.apply({'lldp': {'system_name': '', 'chassis_id': 'x'}})['system_name'] == 'large1'
|
||||
|
||||
def test_other_port_is_untouched(self):
|
||||
assert self.apply({'lldp': None}, sw_port=11) is None
|
||||
|
||||
def test_non_host_client_is_ignored(self):
|
||||
switches = {'sw': {'ports': {'Port 10': {'port_idx': 10, 'lldp': None}}}}
|
||||
devices.apply_client_locations(
|
||||
switches, [{'mac': 'cc:cc:cc:cc:cc:cc', 'sw_mac': 'bb:bb:bb:bb:bb:01', 'sw_port': 10}],
|
||||
self.HOSTS, self.DEVS,
|
||||
)
|
||||
assert switches['sw']['ports']['Port 10']['lldp'] is None
|
||||
@@ -0,0 +1,500 @@
|
||||
"""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__)))
|
||||
|
||||
from diagnose import DiagnosticsRunner # noqa: E402
|
||||
|
||||
|
||||
# ── build_ssh_command ────────────────────────────────────────────────────────
|
||||
|
||||
class TestBuildSshCommand:
|
||||
def test_contains_stricthostkeychecking_accept_new(self):
|
||||
cmd = DiagnosticsRunner.build_ssh_command('10.0.0.1', 'eth0')
|
||||
assert 'StrictHostKeyChecking=accept-new' in cmd
|
||||
|
||||
def test_contains_host_ip(self):
|
||||
cmd = DiagnosticsRunner.build_ssh_command('10.0.0.1', 'eth0')
|
||||
assert 'root@10.0.0.1' in cmd
|
||||
|
||||
def test_contains_interface_name(self):
|
||||
cmd = DiagnosticsRunner.build_ssh_command('10.0.0.1', 'eth0')
|
||||
assert 'eth0' in cmd
|
||||
|
||||
def test_shell_quotes_special_chars_in_iface(self):
|
||||
# shlex.quote wraps the whole iface string in single quotes so
|
||||
# shell metacharacters are not interpreted as commands
|
||||
cmd = DiagnosticsRunner.build_ssh_command('10.0.0.1', "eth0; rm -rf /")
|
||||
# The iface must appear inside single quotes
|
||||
assert "'eth0; rm -rf /'" in cmd
|
||||
|
||||
def test_contains_sysfs_stats_section(self):
|
||||
cmd = DiagnosticsRunner.build_ssh_command('10.0.0.1', 'eth0')
|
||||
assert 'sysfs_stats' in cmd
|
||||
|
||||
def test_contains_ethtool_section(self):
|
||||
cmd = DiagnosticsRunner.build_ssh_command('10.0.0.1', 'eth0')
|
||||
assert 'ethtool' in cmd
|
||||
|
||||
def test_dmesg_uses_fixed_string_grep(self):
|
||||
# grep -F prevents iface names with dots (e.g. eth0.1) being treated as
|
||||
# regex wildcards; -- prevents leading - from being parsed as a flag
|
||||
cmd = DiagnosticsRunner.build_ssh_command('10.0.0.1', 'eth0')
|
||||
assert 'grep -F --' in cmd
|
||||
|
||||
|
||||
# ── parse_output ─────────────────────────────────────────────────────────────
|
||||
|
||||
SAMPLE_OUTPUT = """\
|
||||
=== carrier ===
|
||||
1
|
||||
=== operstate ===
|
||||
up
|
||||
=== sysfs_stats ===
|
||||
rx_bytes:12345
|
||||
tx_bytes:67890
|
||||
rx_errors:0
|
||||
tx_errors:0
|
||||
rx_dropped:0
|
||||
tx_dropped:0
|
||||
rx_crc_errors:0
|
||||
rx_frame_errors:0
|
||||
rx_fifo_errors:0
|
||||
tx_carrier_errors:0
|
||||
collisions:0
|
||||
rx_missed_errors:0
|
||||
=== carrier_changes ===
|
||||
3
|
||||
=== ethtool ===
|
||||
Speed: 1000Mb/s
|
||||
Duplex: Full
|
||||
Link detected: yes
|
||||
Auto-negotiation: on
|
||||
=== ethtool_driver ===
|
||||
driver: igb
|
||||
version: 5.6.0-k
|
||||
firmware-version: 1.67, 0x80000d38
|
||||
bus-info: 0000:03:00.0
|
||||
=== ethtool_pause ===
|
||||
RX: on
|
||||
TX: off
|
||||
=== ethtool_ring ===
|
||||
Pre-set maximums:
|
||||
RX: 4096
|
||||
TX: 4096
|
||||
Current hardware settings:
|
||||
RX: 256
|
||||
TX: 256
|
||||
=== ethtool_stats ===
|
||||
rx_packets: 1000
|
||||
tx_packets: 2000
|
||||
=== ethtool_dom ===
|
||||
=== ip_link ===
|
||||
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500
|
||||
=== ip_addr ===
|
||||
inet 10.0.0.1/24
|
||||
=== ip_route ===
|
||||
default via 10.0.0.254
|
||||
=== dmesg ===
|
||||
eth0: renamed from ens3
|
||||
=== lldpctl ===
|
||||
lldpd not running
|
||||
=== end ===
|
||||
"""
|
||||
|
||||
|
||||
class TestParseOutput:
|
||||
def setup_method(self):
|
||||
self.parsed = DiagnosticsRunner.parse_output(SAMPLE_OUTPUT)
|
||||
|
||||
def test_carrier_parsed(self):
|
||||
assert self.parsed['carrier'] == '1'
|
||||
|
||||
def test_operstate_parsed(self):
|
||||
assert self.parsed['operstate'] == 'up'
|
||||
|
||||
def test_carrier_changes_is_int(self):
|
||||
assert self.parsed['carrier_changes'] == 3
|
||||
|
||||
def test_sysfs_stats_rx_bytes(self):
|
||||
assert self.parsed['sysfs_stats']['rx_bytes'] == 12345
|
||||
|
||||
def test_sysfs_stats_tx_bytes(self):
|
||||
assert self.parsed['sysfs_stats']['tx_bytes'] == 67890
|
||||
|
||||
def test_ethtool_speed(self):
|
||||
assert self.parsed['ethtool']['speed_mbps'] == 1000
|
||||
|
||||
def test_ethtool_link_detected(self):
|
||||
assert self.parsed['ethtool']['link_detected'] is True
|
||||
|
||||
def test_ethtool_duplex(self):
|
||||
assert self.parsed['ethtool']['duplex'] == 'full'
|
||||
|
||||
def test_ethtool_auto_neg(self):
|
||||
assert self.parsed['ethtool']['auto_neg'] is True
|
||||
|
||||
def test_ethtool_driver(self):
|
||||
assert self.parsed['ethtool_driver']['driver'] == 'igb'
|
||||
|
||||
def test_ethtool_pause_rx_on(self):
|
||||
assert self.parsed['ethtool_pause']['rx_pause'] is True
|
||||
|
||||
def test_ethtool_pause_tx_off(self):
|
||||
assert self.parsed['ethtool_pause']['tx_pause'] is False
|
||||
|
||||
def test_ethtool_ring_current(self):
|
||||
assert self.parsed['ethtool_ring']['rx_current'] == 256
|
||||
assert self.parsed['ethtool_ring']['tx_current'] == 256
|
||||
|
||||
def test_ethtool_ring_max(self):
|
||||
assert self.parsed['ethtool_ring']['rx_max'] == 4096
|
||||
|
||||
def test_ip_addr_present(self):
|
||||
assert '10.0.0.1/24' in self.parsed['ip_addr']
|
||||
|
||||
def test_ip_route_present(self):
|
||||
assert 'default via 10.0.0.254' in self.parsed['ip_route']
|
||||
|
||||
|
||||
class TestParseOutputEdgeCases:
|
||||
def test_empty_string_returns_dict(self):
|
||||
result = DiagnosticsRunner.parse_output('')
|
||||
assert isinstance(result, dict)
|
||||
assert result['carrier'] == '?'
|
||||
assert result['operstate'] == '?'
|
||||
assert result['carrier_changes'] == 0
|
||||
|
||||
def test_no_end_sentinel_still_parses(self):
|
||||
output = "=== carrier ===\n1\n=== operstate ===\nup\n"
|
||||
result = DiagnosticsRunner.parse_output(output)
|
||||
assert result['carrier'] == '1'
|
||||
|
||||
|
||||
# ── parse_sysfs_stats ────────────────────────────────────────────────────────
|
||||
|
||||
class TestParseSysfsStats:
|
||||
def test_parses_known_keys(self):
|
||||
text = "rx_bytes:100\ntx_bytes:200\nrx_errors:0\n"
|
||||
result = DiagnosticsRunner.parse_sysfs_stats(text)
|
||||
assert result['rx_bytes'] == 100
|
||||
assert result['tx_bytes'] == 200
|
||||
assert result['rx_errors'] == 0
|
||||
|
||||
def test_ignores_unknown_keys(self):
|
||||
text = "unknown_counter:999\nrx_bytes:50\n"
|
||||
result = DiagnosticsRunner.parse_sysfs_stats(text)
|
||||
assert 'unknown_counter' not in result
|
||||
assert result['rx_bytes'] == 50
|
||||
|
||||
def test_non_numeric_value_defaults_to_zero(self):
|
||||
text = "rx_bytes:not_a_number\n"
|
||||
result = DiagnosticsRunner.parse_sysfs_stats(text)
|
||||
assert result['rx_bytes'] == 0
|
||||
|
||||
def test_empty_text_returns_empty_dict(self):
|
||||
assert DiagnosticsRunner.parse_sysfs_stats('') == {}
|
||||
|
||||
|
||||
# ── parse_ethtool ─────────────────────────────────────────────────────────────
|
||||
|
||||
class TestParseEthtool:
|
||||
def test_speed_parsed(self):
|
||||
text = "Speed: 10000Mb/s\n"
|
||||
result = DiagnosticsRunner.parse_ethtool(text)
|
||||
assert result['speed_mbps'] == 10000
|
||||
|
||||
def test_unknown_speed(self):
|
||||
text = "Speed: Unknown! (0)\n"
|
||||
result = DiagnosticsRunner.parse_ethtool(text)
|
||||
assert result['speed_mbps'] is None
|
||||
|
||||
def test_link_detected_no(self):
|
||||
text = "Link detected: no\n"
|
||||
result = DiagnosticsRunner.parse_ethtool(text)
|
||||
assert result['link_detected'] is False
|
||||
|
||||
def test_auto_neg_off(self):
|
||||
text = "Auto-negotiation: off\n"
|
||||
result = DiagnosticsRunner.parse_ethtool(text)
|
||||
assert result['auto_neg'] is False
|
||||
|
||||
def test_empty_returns_empty(self):
|
||||
assert DiagnosticsRunner.parse_ethtool('') == {}
|
||||
|
||||
|
||||
# ── parse_ethtool_driver ──────────────────────────────────────────────────────
|
||||
|
||||
class TestParseEthtoolDriver:
|
||||
def test_driver_name(self):
|
||||
text = "driver: igb\nversion: 5.6.0-k\nfirmware-version: 1.67\nbus-info: 0000:03:00.0\n"
|
||||
result = DiagnosticsRunner.parse_ethtool_driver(text)
|
||||
assert result['driver'] == 'igb'
|
||||
|
||||
def test_version(self):
|
||||
text = "driver: igb\nversion: 5.6.0-k\n"
|
||||
result = DiagnosticsRunner.parse_ethtool_driver(text)
|
||||
assert result['version'] == '5.6.0-k'
|
||||
|
||||
def test_firmware_version(self):
|
||||
text = "firmware-version: 1.67, 0x80000d38\n"
|
||||
result = DiagnosticsRunner.parse_ethtool_driver(text)
|
||||
assert result['firmware_version'] == '1.67, 0x80000d38'
|
||||
|
||||
def test_bus_info(self):
|
||||
text = "bus-info: 0000:03:00.0\n"
|
||||
result = DiagnosticsRunner.parse_ethtool_driver(text)
|
||||
assert result['bus_info'] == '0000:03:00.0'
|
||||
|
||||
def test_empty_returns_empty(self):
|
||||
assert DiagnosticsRunner.parse_ethtool_driver('') == {}
|
||||
|
||||
|
||||
# ── parse_nic_stats ───────────────────────────────────────────────────────────
|
||||
|
||||
class TestParseNicStats:
|
||||
def test_parses_integer_values(self):
|
||||
text = "rx_packets: 1234\ntx_packets: 5678\n"
|
||||
result = DiagnosticsRunner.parse_nic_stats(text)
|
||||
assert result['rx_packets'] == 1234
|
||||
assert result['tx_packets'] == 5678
|
||||
|
||||
def test_non_numeric_skipped(self):
|
||||
text = "rx_packets: 100\nbad_stat: N/A\n"
|
||||
result = DiagnosticsRunner.parse_nic_stats(text)
|
||||
assert 'bad_stat' not in result
|
||||
assert result['rx_packets'] == 100
|
||||
|
||||
def test_empty_returns_empty(self):
|
||||
assert DiagnosticsRunner.parse_nic_stats('') == {}
|
||||
|
||||
|
||||
# ── parse_ethtool_dom ─────────────────────────────────────────────────────────
|
||||
|
||||
class TestParseEthtoolDom:
|
||||
def test_unsupported_returns_empty(self):
|
||||
assert DiagnosticsRunner.parse_ethtool_dom('Cannot get module EEPROM information') == {}
|
||||
|
||||
def test_empty_returns_empty(self):
|
||||
assert DiagnosticsRunner.parse_ethtool_dom('') == {}
|
||||
|
||||
def test_vendor_name(self):
|
||||
text = "Vendor name : CISCO-FINISAR\n"
|
||||
result = DiagnosticsRunner.parse_ethtool_dom(text)
|
||||
assert result['vendor'] == 'CISCO-FINISAR'
|
||||
|
||||
def test_wavelength(self):
|
||||
text = "Laser wavelength : 1310 nm\n"
|
||||
result = DiagnosticsRunner.parse_ethtool_dom(text)
|
||||
assert result['wavelength_nm'] == 1310
|
||||
|
||||
def test_tx_power_dbm(self):
|
||||
text = "Laser output power : 0.3000 mW / -5.23 dBm\n"
|
||||
result = DiagnosticsRunner.parse_ethtool_dom(text)
|
||||
assert abs(result['tx_power_dbm'] - (-5.23)) < 0.01
|
||||
|
||||
def test_rx_power_dbm(self):
|
||||
text = "Receiver signal average optical power : 0.1000 mW / -10.00 dBm\n"
|
||||
result = DiagnosticsRunner.parse_ethtool_dom(text)
|
||||
assert abs(result['rx_power_dbm'] - (-10.00)) < 0.01
|
||||
|
||||
|
||||
# ── parse_ip_link ─────────────────────────────────────────────────────────────
|
||||
|
||||
class TestParseIpLink:
|
||||
IP_LINK_SAMPLE = """\
|
||||
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP mode DEFAULT group default qlen 1000
|
||||
link/ether aa:bb:cc:dd:ee:ff brd ff:ff:ff:ff:ff:ff
|
||||
RX: bytes packets errors dropped missed mcast
|
||||
123456789 1000000 0 5 0 0
|
||||
TX: bytes packets errors dropped carrier collsns
|
||||
98765432 900000 0 0 0 0
|
||||
"""
|
||||
|
||||
def test_mtu_parsed(self):
|
||||
result = DiagnosticsRunner.parse_ip_link(self.IP_LINK_SAMPLE)
|
||||
assert result['mtu'] == 1500
|
||||
|
||||
def test_state_parsed(self):
|
||||
result = DiagnosticsRunner.parse_ip_link(self.IP_LINK_SAMPLE)
|
||||
assert result['state'] == 'up'
|
||||
|
||||
def test_rx_bytes(self):
|
||||
result = DiagnosticsRunner.parse_ip_link(self.IP_LINK_SAMPLE)
|
||||
assert result['ip_rx_bytes'] == 123456789
|
||||
|
||||
def test_tx_bytes(self):
|
||||
result = DiagnosticsRunner.parse_ip_link(self.IP_LINK_SAMPLE)
|
||||
assert result['ip_tx_bytes'] == 98765432
|
||||
|
||||
def test_rx_dropped(self):
|
||||
result = DiagnosticsRunner.parse_ip_link(self.IP_LINK_SAMPLE)
|
||||
assert result['ip_rx_dropped'] == 5
|
||||
|
||||
def test_empty_returns_empty(self):
|
||||
assert DiagnosticsRunner.parse_ip_link('') == {}
|
||||
|
||||
|
||||
# ── parse_dmesg ───────────────────────────────────────────────────────────────
|
||||
|
||||
class TestParseDmesg:
|
||||
def test_error_severity(self):
|
||||
text = "[ 1.234567] eth0: Link failure detected\n"
|
||||
events = DiagnosticsRunner.parse_dmesg(text)
|
||||
assert len(events) == 1
|
||||
assert events[0]['severity'] == 'error'
|
||||
|
||||
def test_warn_severity(self):
|
||||
text = "[ 2.000000] eth0: dropped packet\n"
|
||||
events = DiagnosticsRunner.parse_dmesg(text)
|
||||
assert events[0]['severity'] == 'warn'
|
||||
|
||||
def test_info_severity(self):
|
||||
text = "[ 3.000000] eth0: NIC Link is Up\n"
|
||||
events = DiagnosticsRunner.parse_dmesg(text)
|
||||
assert events[0]['severity'] == 'info'
|
||||
|
||||
def test_timestamp_extracted(self):
|
||||
text = "[ 5.678900] eth0: reset\n"
|
||||
events = DiagnosticsRunner.parse_dmesg(text)
|
||||
assert events[0]['timestamp'] == '5.678900'
|
||||
|
||||
def test_no_timestamp(self):
|
||||
text = "eth0: some timeout event\n"
|
||||
events = DiagnosticsRunner.parse_dmesg(text)
|
||||
assert events[0]['timestamp'] == ''
|
||||
assert events[0]['severity'] == 'error'
|
||||
|
||||
def test_empty_returns_empty_list(self):
|
||||
assert DiagnosticsRunner.parse_dmesg('') == []
|
||||
|
||||
|
||||
# ── parse_lldpctl ─────────────────────────────────────────────────────────────
|
||||
|
||||
class TestParseLldpctl:
|
||||
def test_unavailable_when_not_running(self):
|
||||
result = DiagnosticsRunner.parse_lldpctl('lldpd not running')
|
||||
assert result == {'available': False}
|
||||
|
||||
def test_unavailable_on_empty(self):
|
||||
result = DiagnosticsRunner.parse_lldpctl('')
|
||||
assert result == {'available': False}
|
||||
|
||||
def test_neighbor_system_parsed(self):
|
||||
text = " SysName: core-sw-01\n PortID: Gi1/0/5\n ChassisID: aa:bb:cc:dd:ee:ff\n"
|
||||
result = DiagnosticsRunner.parse_lldpctl(text)
|
||||
assert result['available'] is True
|
||||
assert result['neighbor_system'] == 'core-sw-01'
|
||||
|
||||
def test_neighbor_port_parsed(self):
|
||||
text = " SysName: core-sw-01\n PortID: Gi1/0/5\n"
|
||||
result = DiagnosticsRunner.parse_lldpctl(text)
|
||||
assert result['neighbor_port'] == 'Gi1/0/5'
|
||||
|
||||
def test_chassis_id_parsed(self):
|
||||
text = " ChassisID: aa:bb:cc:dd:ee:ff\n"
|
||||
result = DiagnosticsRunner.parse_lldpctl(text)
|
||||
assert result['neighbor_chassis_id'] == 'aa:bb:cc:dd:ee:ff'
|
||||
|
||||
|
||||
# ── analyze ───────────────────────────────────────────────────────────────────
|
||||
|
||||
class TestAnalyze:
|
||||
def _sections(self, **overrides):
|
||||
base = {
|
||||
'carrier': '1',
|
||||
'operstate': 'up',
|
||||
'ethtool': {'link_detected': True, 'duplex': 'full', 'speed_mbps': 1000},
|
||||
'sysfs_stats': {'rx_crc_errors': 0},
|
||||
'ethtool_dom': {},
|
||||
'dmesg': [],
|
||||
'lldpctl': {'available': False},
|
||||
'carrier_changes': 0,
|
||||
}
|
||||
base.update(overrides)
|
||||
return base
|
||||
|
||||
def test_no_carrier_is_issue(self):
|
||||
result = DiagnosticsRunner.analyze(self._sections(carrier='0'), {})
|
||||
codes = [i['code'] for i in result['issues']]
|
||||
assert 'NO_CARRIER' in codes
|
||||
|
||||
def test_half_duplex_is_issue(self):
|
||||
sections = self._sections(ethtool={'duplex': 'half', 'link_detected': True, 'speed_mbps': 1000})
|
||||
result = DiagnosticsRunner.analyze(sections, {})
|
||||
codes = [i['code'] for i in result['issues']]
|
||||
assert 'HALF_DUPLEX' in codes
|
||||
|
||||
def test_speed_mismatch_is_warning(self):
|
||||
result = DiagnosticsRunner.analyze(
|
||||
self._sections(ethtool={'duplex': 'full', 'link_detected': True, 'speed_mbps': 100}),
|
||||
{'speed_mbps': 1000}
|
||||
)
|
||||
codes = [w['code'] for w in result['warnings']]
|
||||
assert 'SPEED_MISMATCH' in codes
|
||||
|
||||
def test_sfp_rx_critical_low(self):
|
||||
sections = self._sections(ethtool_dom={'rx_power_dbm': -30.0})
|
||||
result = DiagnosticsRunner.analyze(sections, {})
|
||||
codes = [i['code'] for i in result['issues']]
|
||||
assert 'SFP_RX_CRITICAL' in codes
|
||||
|
||||
def test_sfp_rx_low_is_warning(self):
|
||||
sections = self._sections(ethtool_dom={'rx_power_dbm': -20.0})
|
||||
result = DiagnosticsRunner.analyze(sections, {})
|
||||
codes = [w['code'] for w in result['warnings']]
|
||||
assert 'SFP_RX_LOW' in codes
|
||||
|
||||
def test_high_crc_is_issue(self):
|
||||
sections = self._sections(sysfs_stats={'rx_crc_errors': 200})
|
||||
result = DiagnosticsRunner.analyze(sections, {})
|
||||
codes = [i['code'] for i in result['issues']]
|
||||
assert 'CRC_ERRORS_HIGH' in codes
|
||||
|
||||
def test_low_crc_is_warning(self):
|
||||
sections = self._sections(sysfs_stats={'rx_crc_errors': 50})
|
||||
result = DiagnosticsRunner.analyze(sections, {})
|
||||
codes = [w['code'] for w in result['warnings']]
|
||||
assert 'CRC_ERRORS_LOW' in codes
|
||||
|
||||
def test_carrier_flapping_issue(self):
|
||||
result = DiagnosticsRunner.analyze(self._sections(carrier_changes=150), {})
|
||||
codes = [i['code'] for i in result['issues']]
|
||||
assert 'CARRIER_FLAPPING' in codes
|
||||
|
||||
def test_carrier_flaps_warning(self):
|
||||
result = DiagnosticsRunner.analyze(self._sections(carrier_changes=25), {})
|
||||
codes = [w['code'] for w in result['warnings']]
|
||||
assert 'CARRIER_FLAPS' in codes
|
||||
|
||||
def test_lldp_missing_is_info(self):
|
||||
result = DiagnosticsRunner.analyze(self._sections(lldpctl={'available': False}), {})
|
||||
codes = [i['code'] for i in result['info']]
|
||||
assert 'LLDP_MISSING' in codes
|
||||
|
||||
def test_lldp_mismatch_is_warning(self):
|
||||
# The server's lldpd sees a different switch than the one this port belongs to.
|
||||
sections = self._sections(lldpctl={'available': True, 'neighbor_system': 'wrong-switch'})
|
||||
switch_data = {'speed_mbps': 1000, 'switch_name': 'core-sw-01', 'lldp': {'system_name': 'server-a'}}
|
||||
result = DiagnosticsRunner.analyze(sections, switch_data)
|
||||
codes = [w['code'] for w in result['warnings']]
|
||||
assert 'LLDP_MISMATCH' in codes
|
||||
|
||||
def test_lldp_match_is_not_a_warning(self):
|
||||
# Correct cabling: the switch sees the server, the server sees the switch.
|
||||
sections = self._sections(lldpctl={'available': True, 'neighbor_system': 'core-sw-01'})
|
||||
switch_data = {'speed_mbps': 1000, 'switch_name': 'core-sw-01', 'lldp': {'system_name': 'server-a'}}
|
||||
result = DiagnosticsRunner.analyze(sections, switch_data)
|
||||
codes = [w['code'] for w in result['warnings']]
|
||||
assert 'LLDP_MISMATCH' not in codes
|
||||
|
||||
def test_lldp_without_switch_name_skips_check(self):
|
||||
sections = self._sections(lldpctl={'available': True, 'neighbor_system': 'anything'})
|
||||
result = DiagnosticsRunner.analyze(sections, {'speed_mbps': 1000, 'lldp': {'system_name': 'server-a'}})
|
||||
codes = [w['code'] for w in result['warnings']]
|
||||
assert 'LLDP_MISMATCH' not in codes
|
||||
|
||||
def test_healthy_link_no_issues(self):
|
||||
result = DiagnosticsRunner.analyze(self._sections(), {})
|
||||
assert result['issues'] == []
|
||||
assert result['warnings'] == []
|
||||
@@ -0,0 +1,69 @@
|
||||
"""kuma.py: switching the Uptime Kuma maintenance window, against a fake Socket.IO client."""
|
||||
import os
|
||||
import sys
|
||||
|
||||
import pytest
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
|
||||
import kuma # noqa: E402
|
||||
|
||||
CFG = {'url': 'http://kuma.test:3001', 'username': 'gandalf', 'password': 'pw', 'maintenance_id': 7}
|
||||
|
||||
|
||||
class FakeSocket:
|
||||
def __init__(self, answers=None, connect_error=None):
|
||||
self.answers = answers or {}
|
||||
self.connect_error = connect_error
|
||||
self.calls, self.disconnected = [], False
|
||||
|
||||
def connect(self, url, **kw):
|
||||
if self.connect_error:
|
||||
raise self.connect_error
|
||||
self.url = url
|
||||
|
||||
def call(self, event, data=None, timeout=None):
|
||||
self.calls.append((event, data))
|
||||
return self.answers.get(event, {'ok': True})
|
||||
|
||||
def disconnect(self):
|
||||
self.disconnected = True
|
||||
|
||||
|
||||
def run(active=True, **kw):
|
||||
sock = FakeSocket(**kw)
|
||||
kuma.set_maintenance(CFG, active, client_factory=lambda: sock)
|
||||
return sock
|
||||
|
||||
|
||||
class TestKuma:
|
||||
def test_configured_needs_every_field(self):
|
||||
assert kuma.configured(CFG)
|
||||
assert not kuma.configured(dict(CFG, password=''))
|
||||
assert not kuma.configured(None)
|
||||
|
||||
def test_resume_logs_in_then_switches_the_window_on(self):
|
||||
sock = run(True)
|
||||
assert sock.calls == [('login', {'username': 'gandalf', 'password': 'pw', 'token': ''}),
|
||||
('resumeMaintenance', 7)]
|
||||
assert sock.disconnected and sock.url == CFG['url']
|
||||
|
||||
def test_pause(self):
|
||||
assert run(False).calls[-1] == ('pauseMaintenance', 7)
|
||||
|
||||
def test_refused_login(self):
|
||||
with pytest.raises(kuma.KumaError, match='login refused: Incorrect username or password'):
|
||||
run(answers={'login': {'ok': False, 'msg': 'Incorrect username or password.'}})
|
||||
|
||||
def test_two_factor_account(self):
|
||||
with pytest.raises(kuma.KumaError, match='two-factor'):
|
||||
run(answers={'login': {'ok': False, 'tokenRequired': True}})
|
||||
|
||||
def test_refused_change(self):
|
||||
with pytest.raises(kuma.KumaError, match='resumeMaintenance refused'):
|
||||
run(answers={'resumeMaintenance': {'ok': False, 'msg': 'not found'}})
|
||||
|
||||
def test_unreachable(self):
|
||||
sock = FakeSocket(connect_error=ConnectionError('refused'))
|
||||
with pytest.raises(kuma.KumaError, match='ConnectionError'):
|
||||
kuma.set_maintenance(CFG, True, client_factory=lambda: sock)
|
||||
assert sock.disconnected
|
||||
@@ -0,0 +1,560 @@
|
||||
"""Tests for modem.py parsing. Fixtures copy the BGW320-505 (fw 6.35.8) markup with sanitized values."""
|
||||
import os
|
||||
import sys
|
||||
from unittest.mock import MagicMock
|
||||
|
||||
import pytest
|
||||
import requests
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
|
||||
|
||||
import modem # noqa: E402
|
||||
|
||||
|
||||
def dom_table(heading, current, flags=(0, 0, 0, 0), limits=(-292, -90, -279, -100)):
|
||||
return f'''
|
||||
<h1>{heading} Currently {current}</h1>
|
||||
<table class="grid table100" summary="{heading} table">
|
||||
<thead><tr><th scope="col" width="30%"> </th><th scope="col">Low</th><th scope="col">High</th></tr></thead>
|
||||
<tbody>
|
||||
<tr class="a"><td class="heading" scope="row">Alarm</td>
|
||||
<td>{flags[0]} (Threshold {limits[0]})</td>
|
||||
<td>{flags[1]} (Threshold {limits[1]})</td>
|
||||
</tr>
|
||||
<tr class="b"><td class="heading" scope="row">Warning</td>
|
||||
<td>{flags[2]} (Threshold {limits[2]})</td>
|
||||
<td>{flags[3]} (Threshold {limits[3]})</td>
|
||||
</tr>
|
||||
</tbody></table>'''
|
||||
|
||||
|
||||
def fiber_page(optical='Up', rx=-169, rx_flags=(0, 0, 0, 0), include_rx=True):
|
||||
rx_table = dom_table('Rx Power', rx, rx_flags) if include_rx else ''
|
||||
return f'''<html><title>Fiber Status</title>
|
||||
<tr><th scope="row" width="47%">Optical WAN Operational Status</th>
|
||||
<td class="col2">{optical} </td></tr>
|
||||
<tr><th scope="row">Wave Length</th><td class="col2">1270 nm </td></tr>
|
||||
<tr><th scope="row">Rx LOS State</th><td class="col2">1</td></tr>
|
||||
<tr><th scope="row">Vendor PN</th><td class="col2">TESTPN</td></tr>
|
||||
{dom_table('Temperature', 34, limits=(-50, 95, -45, 90))}
|
||||
{dom_table('Vcc', 3, limits=(3, 3, 3, 3))}
|
||||
{dom_table('Tx Bias', 6, limits=(0, 500, 0, 400))}
|
||||
{dom_table('Tx Power', 33, limits=(-10, 59, 0, 49))}
|
||||
{rx_table}</html>'''
|
||||
|
||||
|
||||
def broadband_page(connection='Up', pon='OPERATION (O5)'):
|
||||
return f'''<html><title>Broadband Status</title>
|
||||
<tr><th scope="row" width="47%">Broadband Connection Source</th><td class="col2">FIBER</td></tr>
|
||||
<tr><th scope="row" width="47%">Broadband Connection</th>
|
||||
<td class="col2">
|
||||
{connection}
|
||||
</td></tr>
|
||||
<tr><th scope="row">Broadband IPv4 Address</th><td class="col2">203.0.113.10</td></tr>
|
||||
<tr class="a"><th scope="row" class="heading a">Current Speed (Mbps)</th><td>10000</td></tr>
|
||||
<tr><th scope="row">Transmit Bytes</th><td>200</td></tr>
|
||||
<tr><th scope="row">Receive Bytes</th><td>100</td></tr>
|
||||
<tr><th scope="row">Receive Errors</th><td>1</td></tr>
|
||||
<tr><th scope="row">Transmit Errors</th><td>2</td></tr>
|
||||
<tr><th scope="row">Receive Drops</th><td>3</td></tr>
|
||||
<tr><th scope="row">Transmit Drops</th><td>4</td></tr>
|
||||
<tr><th scope="row">Transmit Packets</th><td>7</td></tr>
|
||||
<tr><th scope="row">Transmit Packets</th><td>999</td></tr>
|
||||
<tr><th scope="row">PON Link Status</th><td>{pon}</td></tr>
|
||||
<tr><th scope="row">UNI Status</th><td>up</td></tr></html>'''
|
||||
|
||||
|
||||
SYSINFO = '''<tr><th scope="row">Model Number</th><td class="col2">BGW320-505</td></tr>
|
||||
<tr><th scope="row">Software Version</th><td class="col2">6.35.8</td></tr>
|
||||
<tr><th scope="row">Time Since Last Reboot</th><td class="col2">28951</td></tr>'''
|
||||
|
||||
|
||||
class TestBuildStatus:
|
||||
def test_scales_optical_power_from_tenths_of_dbm(self):
|
||||
d = modem.build_status(fiber_page(), broadband_page(), SYSINFO)
|
||||
assert d['optics']['rx_power']['value'] == -16.9
|
||||
assert d['optics']['tx_power']['value'] == 3.3
|
||||
assert d['optics']['temperature']['value'] == 34.0
|
||||
|
||||
def test_scales_thresholds(self):
|
||||
rx = modem.build_status(fiber_page(), broadband_page())['optics']['rx_power']
|
||||
assert (rx['alarm_low'], rx['alarm_high'], rx['warn_low'], rx['warn_high']) == (-29.2, -9.0, -27.9, -10.0)
|
||||
|
||||
def test_unit_ambiguous_readings_are_dropped_but_flags_kept(self):
|
||||
d = modem.build_status(fiber_page(), broadband_page())
|
||||
assert d['optics']['tx_bias']['value'] is None
|
||||
assert d['optics']['vcc']['alarm_low'] is None
|
||||
assert d['optics']['vcc']['alarm_flag'] is False
|
||||
|
||||
def test_system_and_wan_fields(self):
|
||||
d = modem.build_status(fiber_page(), broadband_page(), SYSINFO)
|
||||
assert d['model'] == 'BGW320-505'
|
||||
assert d['firmware'] == '6.35.8'
|
||||
assert d['uptime_s'] == 28951
|
||||
assert d['broadband_state'] == 'Up'
|
||||
assert d['line_speed_mbps'] == 10000
|
||||
assert d['counters'] == {
|
||||
'rx_bytes': 100, 'tx_bytes': 200, 'rx_errors': 1,
|
||||
'tx_errors': 2, 'rx_drops': 3, 'tx_drops': 4,
|
||||
}
|
||||
|
||||
def test_repeated_label_keeps_first_value(self):
|
||||
assert modem.parse_rows(broadband_page())['Transmit Packets'] == '7'
|
||||
|
||||
def test_sysinfo_is_optional(self):
|
||||
d = modem.build_status(fiber_page(), broadband_page(), '')
|
||||
assert d['model'] == '' and d['uptime_s'] is None
|
||||
|
||||
def test_unknown_page_is_invalid(self):
|
||||
with pytest.raises(modem.ModemDataInvalid):
|
||||
modem.build_status('<html>nope</html>', broadband_page())
|
||||
with pytest.raises(modem.ModemDataInvalid):
|
||||
modem.build_status(fiber_page(), '<html>nope</html>')
|
||||
|
||||
def test_up_link_without_rx_power_is_invalid(self):
|
||||
with pytest.raises(modem.ModemDataInvalid):
|
||||
modem.build_status(fiber_page(include_rx=False), broadband_page())
|
||||
|
||||
def test_cut_fiber_without_rx_power_is_not_invalid(self):
|
||||
d = modem.build_status(fiber_page(optical='Down', include_rx=False), broadband_page(connection='Down'))
|
||||
assert 'rx_power' not in d['optics']
|
||||
assert modem.wan_problems(d)
|
||||
|
||||
|
||||
class TestWanProblems:
|
||||
def test_healthy_link_has_none(self):
|
||||
assert modem.wan_problems(modem.build_status(fiber_page(), broadband_page())) == []
|
||||
|
||||
@pytest.mark.parametrize('field,value,expected', [
|
||||
('broadband_state', 'Down', 'broadband connection is Down'),
|
||||
('optical_state', 'Down', 'optical WAN is Down'),
|
||||
('pon_state', 'INITIAL (O1)', 'PON link state is INITIAL (O1)'),
|
||||
])
|
||||
def test_each_failure_is_reported(self, field, value, expected):
|
||||
d = {'broadband_state': 'Up', 'optical_state': 'Up', 'pon_state': 'OPERATION (O5)', field: value}
|
||||
assert modem.wan_problems(d) == [expected]
|
||||
|
||||
def test_missing_pon_field_is_not_a_problem(self):
|
||||
assert modem.wan_problems({'broadband_state': 'Up', 'optical_state': 'Up', 'pon_state': ''}) == []
|
||||
|
||||
def test_rx_los_pin_is_ignored(self):
|
||||
# Real gateways report Rx LOS State=1 on a healthy link (see fixture).
|
||||
assert modem.wan_problems(modem.build_status(fiber_page(), broadband_page())) == []
|
||||
|
||||
|
||||
class TestMetricStatus:
|
||||
@pytest.mark.parametrize('rx,expected', [
|
||||
(-169, 'ok'),
|
||||
(-279, 'warning'),
|
||||
(-285, 'warning'),
|
||||
(-292, 'alarm'),
|
||||
(-400, 'alarm'),
|
||||
(-100, 'warning'),
|
||||
(-90, 'alarm'),
|
||||
])
|
||||
def test_rx_thresholds(self, rx, expected):
|
||||
rx_metric = modem.parse_dom_metrics(fiber_page(rx=rx))['rx_power']
|
||||
assert modem.metric_status(rx_metric) == expected
|
||||
|
||||
def test_module_flags_win_over_reading(self):
|
||||
alarm = modem.parse_dom_metrics(fiber_page(rx_flags=(1, 0, 0, 0)))['rx_power']
|
||||
warn = modem.parse_dom_metrics(fiber_page(rx_flags=(0, 0, 1, 0)))['rx_power']
|
||||
assert modem.metric_status(alarm) == 'alarm'
|
||||
assert modem.metric_status(warn) == 'warning'
|
||||
|
||||
def test_flag_only_metric(self):
|
||||
assert modem.metric_status(modem.parse_dom_metrics(fiber_page())['vcc']) == 'ok'
|
||||
|
||||
|
||||
class TestCounterRates:
|
||||
def test_rate_from_delta(self):
|
||||
assert modem.counter_rates({'rx_bytes': 300}, {'rx_bytes': 100}, 100)['rx_bytes'] == 2.0
|
||||
|
||||
def test_first_poll_is_none(self):
|
||||
assert modem.counter_rates({'rx_bytes': 300}, None, 100)['rx_bytes'] is None
|
||||
|
||||
def test_reboot_counter_reset_is_none(self):
|
||||
assert modem.counter_rates({'rx_bytes': 5}, {'rx_bytes': 100}, 100)['rx_bytes'] is None
|
||||
|
||||
|
||||
class TestClient:
|
||||
def _client(self, **response):
|
||||
c = modem.ModemClient({'url': 'http://modem.test/'})
|
||||
resp = MagicMock(status_code=response.get('status', 200), text=response.get('text', ''))
|
||||
c.session.get = MagicMock(return_value=resp)
|
||||
return c
|
||||
|
||||
def test_network_failure_is_unreachable(self):
|
||||
c = self._client()
|
||||
c.session.get = MagicMock(side_effect=requests.ConnectionError('boom'))
|
||||
with pytest.raises(modem.ModemUnreachable):
|
||||
c.poll()
|
||||
|
||||
def test_redirect_is_invalid_and_not_followed(self):
|
||||
c = self._client(status=302)
|
||||
with pytest.raises(modem.ModemDataInvalid):
|
||||
c.poll()
|
||||
assert c.session.get.call_args.kwargs['allow_redirects'] is False
|
||||
|
||||
def test_login_page_is_invalid(self):
|
||||
with pytest.raises(modem.ModemDataInvalid, match='login'):
|
||||
self._client(text='<html><title>Login</title></html>').poll()
|
||||
|
||||
|
||||
class TestWanHistory:
|
||||
def ev(self, key, ts, device='RPDU'):
|
||||
return {'key': key, 'ts': ts, 'device': device, 'wan': 'WAN1'}
|
||||
|
||||
def test_outage_opens_and_closes(self):
|
||||
h = {}
|
||||
modem.apply_wan_events(h, [self.ev(modem.LOG_WAN_FAILED, 100), self.ev(modem.LOG_WAN_RESTORED, 200)])
|
||||
assert h['outages'] == [{'failed_at': 100, 'restored_at': 200, 'wan': 'WAN1'}]
|
||||
|
||||
def test_events_are_handled_in_time_order(self):
|
||||
h = {}
|
||||
modem.apply_wan_events(h, [self.ev(modem.LOG_WAN_RESTORED, 200), self.ev(modem.LOG_WAN_FAILED, 100)])
|
||||
assert h['outages'][0]['restored_at'] == 200
|
||||
|
||||
def test_outage_spanning_two_batches(self):
|
||||
h = {}
|
||||
modem.apply_wan_events(h, [self.ev(modem.LOG_WAN_FAILED, 100)])
|
||||
assert h['outages'][0]['restored_at'] is None
|
||||
modem.apply_wan_events(h, [self.ev(modem.LOG_WAN_RESTORED, 200)])
|
||||
assert h['outages'][0]['restored_at'] == 200
|
||||
|
||||
def test_repeat_failure_does_not_open_a_second_outage(self):
|
||||
h = {}
|
||||
modem.apply_wan_events(h, [self.ev(modem.LOG_WAN_FAILED, 100), self.ev(modem.LOG_WAN_FAILED, 150)])
|
||||
assert len(h['outages']) == 1
|
||||
|
||||
def test_restored_without_failure_is_ignored(self):
|
||||
h = {}
|
||||
modem.apply_wan_events(h, [self.ev(modem.LOG_WAN_RESTORED, 200)])
|
||||
assert h['outages'] == []
|
||||
|
||||
def test_blip_is_not_actionable_but_restart_and_instability_are(self):
|
||||
keys = [modem.LOG_WAN_FAILED, modem.LOG_WAN_RESTORED, modem.LOG_MODEM_RESTARTED, modem.LOG_WAN_UNSTABLE]
|
||||
got = modem.apply_wan_events({}, [self.ev(k, i) for i, k in enumerate(keys)])
|
||||
assert [e['key'] for e in got] == [modem.LOG_MODEM_RESTARTED, modem.LOG_WAN_UNSTABLE]
|
||||
|
||||
def test_history_is_bounded(self):
|
||||
h = {}
|
||||
for i in range(60):
|
||||
modem.apply_wan_events(h, [
|
||||
self.ev(modem.LOG_WAN_FAILED, i * 2), self.ev(modem.LOG_WAN_RESTORED, i * 2 + 1),
|
||||
])
|
||||
assert len(h['outages']) == 50
|
||||
|
||||
def test_uptime_reset_confirms_logged_restart(self):
|
||||
h = {}
|
||||
modem.apply_wan_events(h, [self.ev(modem.LOG_MODEM_RESTARTED, 1000)])
|
||||
modem.record_uptime_reset(h, 1023)
|
||||
assert h['restarts'] == [{'at': 1000, 'by': 'RPDU', 'confirmed': True}]
|
||||
|
||||
def test_unexplained_uptime_reset_is_recorded(self):
|
||||
h = {}
|
||||
modem.record_uptime_reset(h, 5000)
|
||||
assert h['restarts'] == [{'at': 5000, 'by': None, 'confirmed': True}]
|
||||
|
||||
|
||||
def _dashboard(health, downtime=(), latencies=None, group='WAN'):
|
||||
return {
|
||||
'wan_history': {'wan_history_details': [{
|
||||
'network_group': group,
|
||||
'health_history': [dict({'timestamp': ts * 1000, 'high_latency': False, 'packet_loss': False,
|
||||
'wan_downtime': False}, **flags) for ts, flags in health],
|
||||
'downtime_history': [{'timestamp': ts * 1000, 'downtime_in_seconds': s} for ts, s in downtime],
|
||||
}]},
|
||||
'wan': {'wan_details': [{'network_group': group, 'stats': {'service_latencies': [
|
||||
{'service_name': k, 'latency': v} for k, v in (latencies or {}).items()]}}]},
|
||||
}
|
||||
|
||||
|
||||
class TestWanQuality:
|
||||
def test_worst_flag_wins_and_periods_are_in_time_order(self):
|
||||
q = modem.wan_quality(_dashboard([
|
||||
(600, {'high_latency': True, 'packet_loss': True}),
|
||||
(0, {}),
|
||||
(300, {'high_latency': True}),
|
||||
(900, {'wan_downtime': True, 'packet_loss': True}),
|
||||
]), now=1000)
|
||||
assert [p['state'] for p in q['periods']] == ['ok', 'latency', 'loss', 'down']
|
||||
assert [p['ts'] for p in q['periods']] == [0, 300, 600, 900]
|
||||
assert q['updated'] == 1000 and q['wan'] == 'WAN'
|
||||
|
||||
def test_downtime_and_latencies(self):
|
||||
q = modem.wan_quality(_dashboard([(0, {})], downtime=[(500, 90)],
|
||||
latencies={'cloudflare': 12, 'google': 26}), now=1)
|
||||
assert q['downtime'] == [{'ts': 500, 'seconds': 90}]
|
||||
assert q['latencies'] == {'cloudflare': 12, 'google': 26}
|
||||
|
||||
def test_prefers_the_primary_wan(self):
|
||||
d = _dashboard([(0, {'high_latency': True})], group='WAN2')
|
||||
d['wan_history']['wan_history_details'].append(
|
||||
_dashboard([(0, {})])['wan_history']['wan_history_details'][0])
|
||||
assert modem.wan_quality(d, 0)['periods'][0]['state'] == 'ok'
|
||||
|
||||
@pytest.mark.parametrize('dashboard', [None, {}, {'wan_history': {}}, {'wan_history': {'wan_history_details': []}}])
|
||||
def test_missing_history_is_none(self, dashboard):
|
||||
assert modem.wan_quality(dashboard, 0) is None
|
||||
|
||||
def test_counts_since(self):
|
||||
periods = [{'ts': 0, 'state': 'latency'}, {'ts': 300, 'state': 'ok'}, {'ts': 600, 'state': 'loss'}]
|
||||
assert modem.quality_counts(periods, 300) == {'ok': 1, 'latency': 0, 'loss': 1, 'down': 0}
|
||||
|
||||
|
||||
# Trimmed from a BGW320-505 (firmware 6.40.4)
|
||||
NAT_PAGE = '''<table class="table60" summary="This table displays a summary of session information.">
|
||||
<tr>
|
||||
<th scope="row" nowrap="nowrap">Total sessions available</th>
|
||||
<td>32767
|
||||
</td></tr>
|
||||
<tr>
|
||||
<th scope="row">Total sessions in use</th>
|
||||
<td>2858
|
||||
</td></tr></table>'''
|
||||
LOGIN_FORM = ('<h1>Access Code Required</h1><form>'
|
||||
'<input type="hidden" name="nonce" value="0a1b2c3d4e5f60718293a4b5c6d7e8f9" />')
|
||||
LOGIN_NO_NONCE = '<h1>Access Code Required</h1><strong>Cookies must be enabled</strong>'
|
||||
DIAG_FORM = ('<form method="post" action="/cgi-bin/diag.ha">'
|
||||
'<input type="hidden" name="nonce" value="ffee00112233445566778899aabbccdd" />')
|
||||
PING_DONE = '''PING 1.1.1.1 (1.1.1.1): 56 data bytes
|
||||
64 bytes from 1.1.1.1: seq=0 ttl=59 time=24.697 ms
|
||||
64 bytes from 1.1.1.1: seq=4 ttl=59 time=12.392 ms
|
||||
|
||||
--- 1.1.1.1 ping statistics ---
|
||||
5 packets transmitted, 5 packets received, 0% packet loss
|
||||
round-trip min/avg/max = 12.392/20.501/32.697 ms
|
||||
test done'''
|
||||
|
||||
|
||||
def _diag(window):
|
||||
return DIAG_FORM + f'<textarea id="progress" name="ProgressWindow" rows="15">{window}</textarea></form>'
|
||||
|
||||
|
||||
class TestModemPages:
|
||||
def test_login_hash_matches_the_page_script(self):
|
||||
# The page posts hex_md5(password + nonce)
|
||||
assert modem.login_hash('abc', '123') == 'e99a18c428cb38d5f260853678922e03'
|
||||
|
||||
def test_login_page_is_recognised(self):
|
||||
assert modem.is_login_page(LOGIN_FORM) and modem.is_login_page(LOGIN_NO_NONCE)
|
||||
assert not modem.is_login_page(NAT_PAGE)
|
||||
|
||||
def test_nat_summary(self):
|
||||
assert modem.parse_nat_summary(NAT_PAGE) == {'in_use': 2858, 'available': 32767}
|
||||
assert modem.parse_nat_summary('<table></table>') is None
|
||||
|
||||
def test_ping_output(self):
|
||||
assert modem.parse_ping_output(PING_DONE) == {
|
||||
'sent': 5, 'received': 5, 'loss_pct': 0, 'min_ms': 12.392, 'avg_ms': 20.501, 'max_ms': 32.697}
|
||||
|
||||
def test_ping_still_running_is_none(self):
|
||||
assert modem.parse_ping_output('PING 1.1.1.1 (1.1.1.1): 56 data bytes\n64 bytes from') is None
|
||||
|
||||
def test_ping_all_lost(self):
|
||||
r = modem.parse_ping_output('5 packets transmitted, 0 packets received, 100% packet loss')
|
||||
assert r['loss_pct'] == 100 and r['avg_ms'] is None
|
||||
|
||||
@pytest.mark.parametrize('gateway,ours,expected', [
|
||||
({'avg_ms': 900.0, 'loss_pct': 0}, 1000, 'upstream'),
|
||||
({'avg_ms': 20.0, 'loss_pct': 40}, 1000, 'upstream'),
|
||||
({'avg_ms': None, 'loss_pct': 100}, None, 'upstream'),
|
||||
({'avg_ms': 20.0, 'loss_pct': 0}, 1000, 'gateway'),
|
||||
({'avg_ms': 20.0, 'loss_pct': 0}, 30, 'clear'),
|
||||
({'avg_ms': 20.0, 'loss_pct': 0}, None, 'clear'),
|
||||
])
|
||||
def test_verdict(self, gateway, ours, expected):
|
||||
assert modem.ping_verdict(gateway, ours) == expected
|
||||
|
||||
|
||||
class FakeGateway:
|
||||
"""Answers ModemAdmin's requests like the BGW320 does."""
|
||||
|
||||
def __init__(self, code='secret', ping_pages=None):
|
||||
self.code, self.logged_in, self.calls = code, False, []
|
||||
self.cookie = self.pinged = False
|
||||
self.ping_pages = list(ping_pages or [_diag(PING_DONE)])
|
||||
|
||||
def __call__(self, method, url, **kw):
|
||||
path = url.split('192.0.2.254', 1)[1]
|
||||
self.calls.append((method, path))
|
||||
if path == '/cgi-bin/login.ha' and method == 'GET':
|
||||
first, self.cookie = not self.cookie, True
|
||||
return MagicMock(status_code=200, text=LOGIN_NO_NONCE if first else LOGIN_FORM)
|
||||
if path == '/cgi-bin/login.ha':
|
||||
ok = kw['data']['hashpassword'] == modem.login_hash(self.code, '0a1b2c3d4e5f60718293a4b5c6d7e8f9')
|
||||
assert set(kw['data']['password']) == {'*'} # the code itself is never sent
|
||||
self.logged_in = ok
|
||||
return MagicMock(status_code=302 if ok else 200, text='' if ok else LOGIN_FORM)
|
||||
if not self.logged_in:
|
||||
return MagicMock(status_code=200, text=LOGIN_FORM)
|
||||
if path == '/cgi-bin/restart.ha' and method == 'GET':
|
||||
return MagicMock(status_code=200, text=DIAG_FORM.replace('diag.ha', 'restart.ha'))
|
||||
if path == '/cgi-bin/nattable.ha':
|
||||
return MagicMock(status_code=200, text=NAT_PAGE)
|
||||
if path == '/cgi-bin/diag.ha' and method == 'POST':
|
||||
assert kw['data']['WebAddress'] == '1.1.1.1' and kw['data']['Ping'] == 'Ping'
|
||||
self.pinged = True
|
||||
return MagicMock(status_code=200, text=_diag(''))
|
||||
if path == '/cgi-bin/diag.ha':
|
||||
# Before the test the window is empty; after it, each refresh shows more output
|
||||
page = self.ping_pages.pop(0) if self.pinged else _diag('')
|
||||
return MagicMock(status_code=200, text=page)
|
||||
raise AssertionError(path)
|
||||
|
||||
|
||||
class TestModemAdmin:
|
||||
def _admin(self, gw, now=None):
|
||||
clock = MagicMock(return_value=now or 1000.0)
|
||||
a = modem.ModemAdmin({'url': 'http://192.0.2.254', 'access_code': 'secret'},
|
||||
clock=clock, sleep=lambda s: None)
|
||||
a.session.request = MagicMock(side_effect=gw)
|
||||
return a, clock
|
||||
|
||||
def test_logs_in_when_needed_and_reads_nat(self):
|
||||
gw = FakeGateway()
|
||||
a, _ = self._admin(gw)
|
||||
assert a.nat_sessions() == {'in_use': 2858, 'available': 32767}
|
||||
assert ('POST', '/cgi-bin/login.ha') in gw.calls
|
||||
gw.calls.clear()
|
||||
a.nat_sessions() # session still good: no second login
|
||||
assert ('POST', '/cgi-bin/login.ha') not in gw.calls
|
||||
|
||||
def test_expired_session_logs_in_again(self):
|
||||
gw = FakeGateway()
|
||||
a, _ = self._admin(gw)
|
||||
a.nat_sessions()
|
||||
gw.logged_in = False
|
||||
assert a.nat_sessions()['in_use'] == 2858
|
||||
|
||||
def test_refused_code_backs_off(self):
|
||||
gw = FakeGateway(code='other')
|
||||
a, clock = self._admin(gw)
|
||||
with pytest.raises(modem.ModemLoginFailed):
|
||||
a.nat_sessions()
|
||||
gw.calls.clear()
|
||||
clock.return_value = 1000.0 + modem.LOGIN_BACKOFF_S - 1
|
||||
with pytest.raises(modem.ModemLoginFailed):
|
||||
a.nat_sessions()
|
||||
assert ('POST', '/cgi-bin/login.ha') not in gw.calls # didn't even try
|
||||
|
||||
def test_ping_from_the_gateway_waits_for_the_result(self):
|
||||
gw = FakeGateway(ping_pages=[_diag('PING 1.1.1.1 (1.1.1.1): 56 data bytes'), _diag(PING_DONE)])
|
||||
a, _ = self._admin(gw)
|
||||
r = a.ping('1.1.1.1')
|
||||
assert r['avg_ms'] == 20.501 and r['target'] == '1.1.1.1'
|
||||
|
||||
def test_ping_that_never_finishes(self):
|
||||
gw = FakeGateway(ping_pages=[_diag('PING ...')] * 50)
|
||||
a, clock = self._admin(gw)
|
||||
clock.side_effect = [1000.0] + [2000.0] * 100
|
||||
with pytest.raises(modem.ModemDataInvalid, match='did not finish'):
|
||||
a.ping('1.1.1.1')
|
||||
|
||||
def test_unreachable(self):
|
||||
a, _ = self._admin(FakeGateway())
|
||||
a.session.request = MagicMock(side_effect=requests.ConnectionError('boom'))
|
||||
with pytest.raises(modem.ModemUnreachable):
|
||||
a.nat_sessions()
|
||||
|
||||
|
||||
FW_LOG = '''<table><tr><th>No.</th><th>Date/Time</th></tr>
|
||||
<tr class="b"><td class="heading" scope="row">2</td><td>2026-11-19T18:32:04.984186</td><td>198.51.100.20</td>
|
||||
<td>203.0.113.7</td><td>TCP</td><td>FLOOD limit 50pps burst 100</td></tr>
|
||||
<tr class="a"><td class="heading" scope="row">1</td><td>2026-11-19T18:32:02.983868</td><td>203.0.113.7</td>
|
||||
<td>198.51.100.30</td><td>TCP</td><td>Invalid IP Packet</td></tr>
|
||||
</table>'''
|
||||
SPEED_PAGE = '''<h2>Test History</h2><table><thead><th scope="col">Test Completion Time</th></thead><tbody>
|
||||
<tr class="b"><td scope="row" class="heading" width="47%">
|
||||
11/06/2026 08:46:05</td>
|
||||
<td>upstream</td>
|
||||
<td> 1242.810000</td>
|
||||
<td> 28</td>
|
||||
<td> 19.000000</td>
|
||||
<td> Success</td></tr>
|
||||
<tr class="a"><td scope="row" class="heading" width="47%">
|
||||
11/06/2026 08:45:57</td>
|
||||
<td>downstream</td>
|
||||
<td> 1167.400000</td>
|
||||
<td> 28</td>
|
||||
<td> 28.000000</td>
|
||||
<td> Success</td></tr>
|
||||
</tbody></table>'''
|
||||
|
||||
|
||||
class TestModemExtras:
|
||||
@pytest.mark.parametrize('raw,expected', [
|
||||
('03:06:29:34', ((3 * 24 + 6) * 60 + 29) * 60 + 34), # firmware 6.40
|
||||
('28951', 28951), # older firmware
|
||||
('0:00:05:00', 300),
|
||||
('', None), (None, None), ('soon', None),
|
||||
])
|
||||
def test_uptime_formats(self, raw, expected):
|
||||
assert modem.parse_uptime(raw) == expected
|
||||
|
||||
def test_status_reads_dhms_uptime(self):
|
||||
sysinfo = SYSINFO.replace('<td class="col2">28951</td>', '<td class="col2">03:06:29:34</td>')
|
||||
assert sysinfo != SYSINFO
|
||||
assert modem.build_status(fiber_page(), broadband_page(), sysinfo)['uptime_s'] == 282574
|
||||
|
||||
def test_firewall_log_oldest_first(self):
|
||||
rows = modem.parse_firewall_log(FW_LOG)
|
||||
assert [r['ts'] for r in rows] == ['2026-11-19T18:32:02.983868', '2026-11-19T18:32:04.984186']
|
||||
assert rows[1]['reason'] == 'FLOOD limit 50pps burst 100' and rows[1]['proto'] == 'TCP'
|
||||
|
||||
@pytest.mark.parametrize('reason,kind', [
|
||||
('FLOOD limit 50pps burst 100', 'flood'), ('Invalid IP Packet', 'invalid'), ('Port scan', 'other')])
|
||||
def test_firewall_kind(self, reason, kind):
|
||||
assert modem.firewall_kind(reason) == kind
|
||||
|
||||
def test_speed_tests(self):
|
||||
assert modem.parse_speed_tests(SPEED_PAGE) == [
|
||||
{'at': '11/06/2026 08:46:05', 'direction': 'upstream', 'mbps': 1242.8, 'latency_ms': 19.0, 'ok': True},
|
||||
{'at': '11/06/2026 08:45:57', 'direction': 'downstream', 'mbps': 1167.4, 'latency_ms': 28.0, 'ok': True},
|
||||
]
|
||||
|
||||
def test_speed_tests_missing(self):
|
||||
assert modem.parse_speed_tests('<html></html>') == []
|
||||
|
||||
|
||||
class TestModemRestart:
|
||||
def _admin(self):
|
||||
gw = FakeGateway()
|
||||
a = modem.ModemAdmin({'url': 'http://192.0.2.254', 'access_code': 'secret'}, sleep=lambda s: None)
|
||||
a.session.request = MagicMock(side_effect=gw)
|
||||
return a, gw
|
||||
|
||||
REDIRECT = MagicMock(status_code=302, headers={'Location': '/cgi-bin/restarting.ha'}, text='')
|
||||
RESTARTING = MagicMock(status_code=200, text='<title>Restarting</title> Your AT&T BGW320-505 is restarting.')
|
||||
|
||||
def test_posts_the_form_then_loads_the_restarting_page(self):
|
||||
# Firmware 6.40: the post only redirects; loading restarting.ha starts the restart
|
||||
a, gw = self._admin()
|
||||
a.session.post = MagicMock(return_value=self.REDIRECT)
|
||||
a.session.get = MagicMock(return_value=self.RESTARTING)
|
||||
assert a.restart() == 'accepted'
|
||||
assert a.session.post.call_args.kwargs['data'] == {'nonce': 'ffee00112233445566778899aabbccdd',
|
||||
'Restart': 'Restart'}
|
||||
assert a.session.post.call_args.args[0].endswith('/cgi-bin/restart.ha')
|
||||
assert a.session.get.call_args.args[0].endswith('/cgi-bin/restarting.ha')
|
||||
assert ('POST', '/cgi-bin/login.ha') in gw.calls # logged in to read the form
|
||||
|
||||
def test_redirect_alone_is_not_a_restart(self):
|
||||
a, _ = self._admin()
|
||||
a.session.post = MagicMock(return_value=self.REDIRECT)
|
||||
a.session.get = MagicMock(return_value=MagicMock(status_code=200, text='<title>Device</title>'))
|
||||
with pytest.raises(modem.ModemDataInvalid, match='not started'):
|
||||
a.restart()
|
||||
|
||||
def test_connection_dropped_mid_restart(self):
|
||||
a, _ = self._admin()
|
||||
a.session.post = MagicMock(return_value=self.REDIRECT)
|
||||
a.session.get = MagicMock(side_effect=requests.ConnectionError('reset'))
|
||||
assert a.restart() == 'unconfirmed'
|
||||
|
||||
def test_refused(self):
|
||||
a, _ = self._admin()
|
||||
a.session.post = MagicMock(return_value=MagicMock(status_code=200, text=LOGIN_FORM))
|
||||
with pytest.raises(modem.ModemDataInvalid, match='not started'):
|
||||
a.restart()
|
||||
@@ -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
|
||||
@@ -0,0 +1,488 @@
|
||||
"""Tests for topology.build_graph, on a small network shaped like the real one."""
|
||||
import os
|
||||
import sys
|
||||
|
||||
import pytest
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
|
||||
|
||||
import topology # noqa: E402
|
||||
|
||||
|
||||
def port(idx, name=None, up=True, speed=1000, neighbour='', port_id='', chassis='', uplink=False, sfp=None,
|
||||
tx=0.0, rx=0.0, source=None):
|
||||
lldp = {}
|
||||
if neighbour or chassis:
|
||||
lldp = {'system_name': neighbour, 'port_id': port_id, 'chassis_id': chassis, 'port_desc': '', 'mgmt_ips': []}
|
||||
if source:
|
||||
lldp['source'] = source
|
||||
p = {'port_idx': idx, 'up': up, 'speed_mbps': speed if up else 0, 'is_uplink': uplink, 'media': 'GE',
|
||||
'lldp': lldp, 'tx_bytes_rate': tx, 'rx_bytes_rate': rx, 'rx_errs_rate': 0.0, 'tx_errs_rate': 0.0,
|
||||
'rx_drops_rate': 0.0, 'tx_drops_rate': 0.0}
|
||||
if sfp:
|
||||
p['sfp'] = dict({'found': True, 'vendor': 'OEM', 'serial': 'SN1'}, **sfp)
|
||||
p['media'] = 'SFP+'
|
||||
return (name or f'Port {idx}'), p
|
||||
|
||||
|
||||
def ports(*items):
|
||||
return dict(items)
|
||||
|
||||
|
||||
def dac(peer=None, peer_port=None):
|
||||
s = {'kind': 'dac', 'part': 'SFP-H10GB-CU1M'}
|
||||
if peer:
|
||||
s['cable_peer'] = {'switch': peer, 'port_idx': peer_port}
|
||||
return s
|
||||
|
||||
|
||||
def network(poe_port_11='Port 11', pbs_up=True):
|
||||
"""Gateway -> aggregation -> PoE switch, two dual-homed hosts, an AP, a PDU and unknown devices."""
|
||||
switches = {
|
||||
'Dream Machine Pro': {'model': 'UDMPRO', 'ports': ports(
|
||||
port(1, neighbour='host-a', port_id='eno2', source='unifi-clients'),
|
||||
port(8), # up, nothing reported: a cable to something Gandalf can't see
|
||||
port(9, uplink=True, chassis='02:00:5e:00:00:09', port_id='02:00:5e:00:00:0a'),
|
||||
port(11, 'Downlink to USW-Aggregation', speed=10000, neighbour='8SFP-AGG', port_id='local Port 7',
|
||||
sfp=dac('8SFP-AGG', 7), tx=2000.0, rx=1000.0),
|
||||
)},
|
||||
'8SFP-AGG': {'model': 'USL8A', 'ports': ports(
|
||||
port(1, 'SFP+ 1', speed=10000, neighbour='host-a', port_id='eno1', sfp={'kind': 'dac', 'part': 'X'}),
|
||||
port(2, 'SFP+ 2', speed=10000, neighbour='host-b', port_id='enp1s0', sfp={'kind': '', 'part': 'L56'}),
|
||||
port(5, 'Downlink to 24RJ45-POE', speed=10000, neighbour='24RJ45-POE', port_id='Port 26',
|
||||
sfp=dac('24RJ45-POE', 26)),
|
||||
port(7, 'SFP+ 7', speed=10000, neighbour='Dream Machine Pro', port_id='02:00:5e:00:00:11',
|
||||
uplink=True, sfp=dac('Dream Machine Pro', 11), tx=1000.0, rx=2000.0),
|
||||
port(8, 'SFP+ 8', speed=10000, neighbour='host-c', port_id='nic4', sfp={'kind': 'optic', 'part': 'SR'}),
|
||||
)},
|
||||
'24RJ45-POE': {'model': 'US24PRO', 'ports': ports(
|
||||
port(1, 'Micro 2 Eth2', chassis='02:00:5e:00:01:01', port_id='02:00:5E:00:01:01'),
|
||||
port(3, 'Living Room Downlink', neighbour='USW Flex', port_id='02:00:5E:00:02:01'),
|
||||
port(4, neighbour='host-b', port_id='enp2s0', source='unifi-clients'),
|
||||
port(8, neighbour='192.0.2.44', port_id='eth0', chassis='02:00:5e:00:01:08', source='unifi-clients'),
|
||||
port(11, poe_port_11, neighbour='AP', port_id='02:00:5E:00:03:01'),
|
||||
port(12, up=False),
|
||||
port(15, 'PBS', up=pbs_up, neighbour='pbs' if pbs_up else '', port_id='enp0s25' if pbs_up else ''),
|
||||
port(19, neighbour='RPDU', port_id='02:00:5E:00:04:01', speed=100),
|
||||
port(26, 'SFP+ 2', speed=10000, neighbour='8SFP-AGG', port_id='Port 5', uplink=True,
|
||||
sfp=dac('8SFP-AGG', 5)),
|
||||
)},
|
||||
'USW Flex': {'model': 'USF5P', 'ports': ports(
|
||||
port(1, uplink=True, neighbour='24RJ45-POE', port_id='Port 3'),
|
||||
port(5, neighbour='UPS 2U Pro', port_id='Port 1', speed=100),
|
||||
)},
|
||||
'RPDU': {'model': 'USPPDUP', 'ports': ports(port(1, uplink=True, speed=100))},
|
||||
}
|
||||
unifi = [
|
||||
{'name': 'Dream Machine Pro', 'type': 'udm', 'model': 'UDMPRO', 'connected': True, 'mac': '', 'ip': ''},
|
||||
{'name': '8SFP-AGG', 'type': 'usw', 'model': 'USL8A', 'connected': True, 'mac': '', 'ip': ''},
|
||||
{'name': '24RJ45-POE', 'type': 'usw', 'model': 'US24PRO', 'connected': True, 'mac': '', 'ip': ''},
|
||||
{'name': 'USW Flex', 'type': 'usw', 'model': 'USF5P', 'connected': True, 'mac': '', 'ip': ''},
|
||||
{'name': 'AP', 'type': 'uap', 'model': 'UAL6', 'connected': True, 'mac': '', 'ip': ''},
|
||||
{'name': 'RPDU', 'type': 'usw', 'model': 'USPPDUP', 'connected': True, 'mac': '', 'ip': ''},
|
||||
{'name': 'UPS 2U Pro', 'type': 'usp', 'model': 'USPDA2B', 'connected': True, 'mac': '', 'ip': ''},
|
||||
{'name': 'USP Strip', 'type': 'uap', 'model': 'UP6', 'connected': True, 'mac': '', 'ip': ''},
|
||||
]
|
||||
hosts = {
|
||||
'host-a': {'status': 'up', 'interfaces': {'eno1': 'up', 'eno2': 'up', 'eno3': 'unused', 'vmbr0': 'up'}},
|
||||
'host-b': {'status': 'degraded',
|
||||
'interfaces': {'bond0': 'up', 'enp1s0': 'up', 'enp2s0': 'up', 'enp3s0': 'down'}},
|
||||
'host-c': {'status': 'up', 'interfaces': {'nic4': 'up'}},
|
||||
'pbs': {'status': 'up' if pbs_up else 'down', 'interfaces': {'enp0s25': 'up' if pbs_up else 'down'}},
|
||||
}
|
||||
snapshot = {'hosts': hosts, 'unifi': unifi}
|
||||
link_stats = {
|
||||
'hosts': {'192.0.2.44': {'eth0': {}}}, # an IP-only Prometheus target
|
||||
'unifi_switches': switches,
|
||||
'unifi_devices': {'Dream Machine Pro': {'wan': {'wan1': {'up': True}}},
|
||||
'RPDU': {'power_w': 120.5, 'outlets': [{'index': 1, 'name': 'AT&T Modem', 'on': True}]}},
|
||||
'updated': '2026-11-14 12:00:00 UTC',
|
||||
}
|
||||
modem = {'name': 'att-modem', 'model': 'BGW320-505', 'reachable': True, 'broadband_state': 'Up',
|
||||
'source': 'FIBER', 'line_speed_mbps': 10000, 'rates': {'rx_bytes': 5000.0, 'tx_bytes': 700.0},
|
||||
'wan_problems': []}
|
||||
return snapshot, link_stats, modem
|
||||
|
||||
|
||||
def build(events=(), items=(), cables=(), known=None, **kw):
|
||||
snapshot, link_stats, modem = network(**kw)
|
||||
return topology.build_graph(snapshot, link_stats, modem, list(events), list(items), list(cables), known)
|
||||
|
||||
|
||||
def find(graph, a, b):
|
||||
"""The links between two nodes, either way round."""
|
||||
return [lk for lk in graph['links'] if {lk['a']['node'], lk['b']['node']} == {a, b}]
|
||||
|
||||
|
||||
def node(graph, name):
|
||||
return next(n for n in graph['nodes'] if n['id'] == name)
|
||||
|
||||
|
||||
class TestSwitchCables:
|
||||
def test_cable_seen_from_both_ends_is_drawn_once(self):
|
||||
g = build()
|
||||
assert len(find(g, 'Dream Machine Pro', '8SFP-AGG')) == 1
|
||||
assert len(find(g, '8SFP-AGG', '24RJ45-POE')) == 1
|
||||
assert len(find(g, '24RJ45-POE', 'USW Flex')) == 1
|
||||
|
||||
def test_both_ports_of_a_switch_cable_are_known(self):
|
||||
g = build()
|
||||
(link,) = find(g, 'Dream Machine Pro', '8SFP-AGG')
|
||||
ends = {link['a']['node']: link['a']['port_idx'], link['b']['node']: link['b']['port_idx']}
|
||||
assert ends == {'Dream Machine Pro': 11, '8SFP-AGG': 7}
|
||||
(flex,) = find(g, '24RJ45-POE', 'USW Flex')
|
||||
assert {flex['a']['port_idx'], flex['b']['port_idx']} == {3, 1}
|
||||
|
||||
def test_gear_without_lldp_lands_on_its_uplink(self):
|
||||
(pdu,) = find(build(), '24RJ45-POE', 'RPDU')
|
||||
assert pdu['b'] == {'node': 'RPDU', 'port_idx': 1, 'port_name': 'Port 1', 'iface': ''}
|
||||
|
||||
def test_cables_point_away_from_the_internet(self):
|
||||
g = build()
|
||||
(link,) = find(g, 'Dream Machine Pro', '8SFP-AGG')
|
||||
assert link['a']['node'] == 'Dream Machine Pro'
|
||||
# The gateway sends 2000 B/s down the cable and gets 1000 back, whichever end measured it
|
||||
assert (link['a_to_b_bps'], link['b_to_a_bps']) == (2000.0, 1000.0)
|
||||
(down,) = find(g, '8SFP-AGG', '24RJ45-POE')
|
||||
assert down['a']['node'] == '8SFP-AGG'
|
||||
|
||||
def test_medium_and_module(self):
|
||||
g = build()
|
||||
assert find(g, 'Dream Machine Pro', '8SFP-AGG')[0]['medium'] == 'dac'
|
||||
assert find(g, '8SFP-AGG', 'host-c')[0]['medium'] == 'fibre'
|
||||
assert find(g, '8SFP-AGG', 'host-b')[0]['medium'] == 'sfp'
|
||||
assert find(g, '24RJ45-POE', 'host-b')[0]['medium'] == 'copper'
|
||||
assert find(g, 'Dream Machine Pro', '8SFP-AGG')[0]['sfp_part'] == 'SFP-H10GB-CU1M'
|
||||
|
||||
|
||||
class TestWanEdge:
|
||||
def test_gateway_to_modem_to_internet(self):
|
||||
g = build()
|
||||
(wan,) = find(g, 'Dream Machine Pro', 'att-modem')
|
||||
assert wan['wan'] and wan['b']['node'] == 'Dream Machine Pro' and wan['a']['node'] == 'att-modem'
|
||||
assert wan['b']['port_idx'] == 9
|
||||
(fibre,) = find(g, 'att-modem', topology.INTERNET)
|
||||
assert fibre['medium'] == 'fibre' and fibre['speed_mbps'] == 10000 and fibre['up']
|
||||
# Down from the internet is what the modem received
|
||||
assert fibre['a_to_b_bps'] == 5000.0
|
||||
|
||||
def test_the_wan_port_is_not_a_stub(self):
|
||||
assert 'stub:Dream Machine Pro:9' not in {n['id'] for n in build()['nodes']}
|
||||
|
||||
def test_without_a_modem_the_gateway_goes_straight_out(self):
|
||||
snapshot, link_stats, _ = network()
|
||||
g = topology.build_graph(snapshot, link_stats, None, [], [], [], None)
|
||||
assert len(find(g, 'Dream Machine Pro', topology.INTERNET)) == 1
|
||||
|
||||
def test_internet_status_follows_the_gateway_wan(self):
|
||||
snapshot, link_stats, modem = network()
|
||||
link_stats['unifi_devices']['Dream Machine Pro']['wan']['wan1']['up'] = False
|
||||
g = topology.build_graph(snapshot, link_stats, modem, [], [], [], None)
|
||||
assert node(g, topology.INTERNET)['status'] == 'down'
|
||||
|
||||
|
||||
class TestHosts:
|
||||
def test_dual_homed_host_has_two_cables(self):
|
||||
g = build()
|
||||
a = [lk for lk in g['links'] if 'host-a' in (lk['a']['node'], lk['b']['node'])]
|
||||
assert sorted((lk['speed_mbps'], lk['b']['iface']) for lk in a) == [(1000, 'eno2'), (10000, 'eno1')]
|
||||
|
||||
def test_physical_nics_only_with_the_cables_on_them(self):
|
||||
nics = {n['name']: n for n in node(build(), 'host-a')['interfaces']}
|
||||
assert set(nics) == {'eno1', 'eno2', 'eno3'}
|
||||
assert nics['eno3']['unused'] and 'links' not in nics['eno3']
|
||||
assert len(nics['eno1']['links']) == 1
|
||||
|
||||
def test_ip_only_target_is_a_stub_not_a_host(self):
|
||||
g = build()
|
||||
assert '192.0.2.44' not in {n['id'] for n in g['nodes'] if n['kind'] != 'stub'}
|
||||
stub = node(g, 'stub:24RJ45-POE:8')
|
||||
assert stub['name'] == '192.0.2.44' and stub['ip'] == '192.0.2.44' and stub['iface'] == 'eth0'
|
||||
|
||||
def test_chassis_comes_from_the_cutsheet_item(self):
|
||||
items = [{'name': 'Server A', 'device': 'host-a', 'chassis': 'sliger-cx4712-red'},
|
||||
{'name': 'host-b', 'device': '', 'chassis': 'zimaboard-832-cx3'}]
|
||||
g = build(items=items)
|
||||
assert node(g, 'host-a')['chassis'] == 'sliger-cx4712-red'
|
||||
assert node(g, 'host-b')['chassis'] == 'zimaboard-832-cx3'
|
||||
assert node(g, 'host-c')['chassis'] == ''
|
||||
|
||||
|
||||
class TestStubs:
|
||||
def test_unnamed_neighbour_is_a_stub_named_by_its_port(self):
|
||||
stub = node(build(), 'stub:24RJ45-POE:1')
|
||||
assert stub['kind'] == 'stub' and stub['name'] == 'Micro 2 Eth2'
|
||||
assert stub['mac'] == '02:00:5e:00:01:01' and not stub['anonymous']
|
||||
|
||||
def test_link_with_no_neighbour_is_an_anonymous_stub(self):
|
||||
stub = node(build(), 'stub:Dream Machine Pro:8')
|
||||
assert stub['anonymous'] and stub['name'] == 'unknown device'
|
||||
|
||||
def test_ports_with_no_link_are_left_out(self):
|
||||
assert 'stub:24RJ45-POE:12' not in {n['id'] for n in build()['nodes']}
|
||||
|
||||
|
||||
class TestNameMismatch:
|
||||
def test_port_named_after_another_device(self):
|
||||
(link,) = find(build(poe_port_11='Large1 Management'), '24RJ45-POE', 'AP')
|
||||
assert link['name_mismatch'] is None # no device called large1 in this network
|
||||
|
||||
def test_flags_when_the_named_device_exists(self):
|
||||
(link,) = find(build(poe_port_11='host-b management'), '24RJ45-POE', 'AP')
|
||||
assert link['name_mismatch'] == {'named': 'host-b', 'actual': 'AP', 'end': 'a'}
|
||||
|
||||
def test_downlink_and_generic_names_are_fine(self):
|
||||
g = build()
|
||||
assert all(lk['name_mismatch'] is None for lk in g['links'])
|
||||
|
||||
@pytest.mark.parametrize('name', ['Port 4', 'SFP+ 2', 'Uplink', 'Downlink to 24RJ45-POE'])
|
||||
def test_names_that_never_flag(self, name):
|
||||
known = {topology._norm(n): n for n in ('24RJ45-POE', 'host-a')}
|
||||
assert topology.name_mismatch(name, '24RJ45-POE', 'x', known) is None
|
||||
|
||||
def test_matches_ignore_case_spacing_and_dashes(self):
|
||||
known = {topology._norm('compute-storage-01'): 'compute-storage-01'}
|
||||
assert topology.name_mismatch('Compute Storage 01 mgmt', 'AP', 'sw', known)['named'] == 'compute-storage-01'
|
||||
|
||||
def test_a_stub_is_checked_against_what_was_seen(self):
|
||||
snapshot, link_stats, modem = network()
|
||||
link_stats['unifi_switches']['24RJ45-POE']['ports']['host-c'] = port(
|
||||
20, 'host-c', chassis='02:00:5e:00:09:09')[1]
|
||||
g = topology.build_graph(snapshot, link_stats, modem, [], [], [], None)
|
||||
(link,) = find(g, '24RJ45-POE', 'stub:24RJ45-POE:20')
|
||||
assert link['name_mismatch']['named'] == 'host-c'
|
||||
|
||||
|
||||
class TestGhosts:
|
||||
KNOWN = {'pbs': {'seen': '2026-11-14 20:49:08 UTC', 'uplinks': [
|
||||
{'switch': '24RJ45-POE', 'port': 'PBS', 'port_idx': 15, 'host_interface': 'enp0s25'}]}}
|
||||
|
||||
def test_missing_host_is_drawn_where_last_seen(self):
|
||||
g = build(known=self.KNOWN, pbs_up=False)
|
||||
(ghost,) = find(g, '24RJ45-POE', 'pbs')
|
||||
assert ghost['ghost'] and not ghost['up'] and ghost['seen'] == '2026-11-14 20:49:08 UTC'
|
||||
assert ghost['b'] == {'node': 'pbs', 'port_idx': None, 'port_name': '', 'iface': 'enp0s25'}
|
||||
|
||||
def test_no_ghost_while_the_host_is_linked(self):
|
||||
g = build(known=self.KNOWN)
|
||||
assert [lk['ghost'] for lk in find(g, '24RJ45-POE', 'pbs')] == [False]
|
||||
|
||||
def test_no_ghost_onto_a_port_now_used_by_something_else(self):
|
||||
known = {'pbs': {'seen': 'x', 'uplinks': [{'switch': '24RJ45-POE', 'port_idx': 4, 'host_interface': 'e'}]}}
|
||||
assert find(build(known=known, pbs_up=False), '24RJ45-POE', 'pbs') == []
|
||||
|
||||
|
||||
class TestDepth:
|
||||
def test_hops_from_the_internet(self):
|
||||
g = build()
|
||||
depths = {n['id']: n['depth'] for n in g['nodes']}
|
||||
assert depths[topology.INTERNET] == 0
|
||||
assert depths['att-modem'] == 1
|
||||
assert depths['Dream Machine Pro'] == 2
|
||||
assert depths['8SFP-AGG'] == 3
|
||||
assert depths['24RJ45-POE'] == 4
|
||||
assert depths['USW Flex'] == 5 and depths['AP'] == 5
|
||||
assert depths['UPS 2U Pro'] == 6
|
||||
# A host's depth is its nearest switch's plus one; hosts never pass the path on
|
||||
assert depths['host-a'] == 3
|
||||
|
||||
def test_unlinked_gear_has_no_depth(self):
|
||||
assert node(build(), 'USP Strip')['depth'] is None
|
||||
|
||||
def test_power_gear_is_marked(self):
|
||||
g = build()
|
||||
assert {n['id']: n['kind'] for n in g['nodes'] if n['power']} == {
|
||||
'RPDU': 'pdu', 'UPS 2U Pro': 'ups', 'USP Strip': 'strip'}
|
||||
assert node(g, 'RPDU')['power_w'] == 120.5
|
||||
|
||||
|
||||
class TestAlerts:
|
||||
def test_active_alerts_count_on_their_device(self):
|
||||
events = [
|
||||
{'id': 1, 'event_type': 'interface_down', 'severity': 'critical', 'target_name': 'host-b',
|
||||
'target_detail': 'enp3s0', 'description': ''},
|
||||
{'id': 2, 'event_type': 'unifi_port_errors', 'severity': 'warning', 'target_name': '24RJ45-POE',
|
||||
'target_detail': 'Port 9', 'description': ''},
|
||||
{'id': 3, 'event_type': 'host_down', 'severity': 'critical', 'target_name': 'host-a',
|
||||
'target_detail': '', 'description': '', 'is_suppressed': True},
|
||||
]
|
||||
g = build(events=events)
|
||||
b = node(g, 'host-b')
|
||||
assert (b['alert_count'], b['severity']) == (1, 'critical')
|
||||
assert next(n for n in b['interfaces'] if n['name'] == 'enp3s0')['alert'] == 'critical'
|
||||
assert node(g, '24RJ45-POE')['severity'] == 'warning'
|
||||
assert node(g, 'host-a')['alert_count'] == 0
|
||||
|
||||
def test_status_comes_from_the_snapshot(self):
|
||||
assert node(build(), 'host-b')['status'] == 'degraded'
|
||||
|
||||
|
||||
class TestCutsheetLabels:
|
||||
def test_cable_label_on_either_end(self):
|
||||
items = [{'name': 'Patch', 'device': '', 'chassis': ''}, {'name': 'UDM-Pro', 'device': 'Dream Machine Pro'}]
|
||||
cables = [{'id': 7, 'label': 'C07', 'a_device': 'UDM-Pro', 'a_port': '8', 'b_device': 'Patch',
|
||||
'b_port': '1', 'status': 'installed', 'cable_type': 'Cat6', 'color': 'Black'},
|
||||
{'id': 8, 'label': 'C08', 'a_device': 'host-a', 'a_port': 'eno2', 'b_device': '',
|
||||
'b_port': '', 'status': 'retired'}]
|
||||
g = build(items=items, cables=cables)
|
||||
(stub,) = find(g, 'Dream Machine Pro', 'stub:Dream Machine Pro:8')
|
||||
assert stub['cable'] == {'id': 7, 'label': 'C07', 'type': 'Cat6', 'color': 'Black',
|
||||
'far': {'device': 'Patch', 'port': '1', 'kind': ''}}
|
||||
# Retired cables are not on the network any more
|
||||
assert find(g, 'Dream Machine Pro', 'host-a')[0]['cable'] is None
|
||||
|
||||
def test_unknown_device_behind_a_patch_panel_is_named_after_it(self):
|
||||
items = [{'name': 'PP1', 'device': '', 'kind': 'patch_panel'},
|
||||
{'name': 'UDM-Pro', 'device': 'Dream Machine Pro'}]
|
||||
cables = [{'id': 7, 'label': 'C07', 'a_device': 'UDM-Pro', 'a_port': '8', 'b_device': 'PP1',
|
||||
'b_port': '3', 'status': 'installed'}]
|
||||
stub = node(build(items=items, cables=cables), 'stub:Dream Machine Pro:8')
|
||||
assert stub['name'] == 'Patch panel port 3' and stub['named_by_via']
|
||||
assert stub['via'] == {'device': 'PP1', 'port': '3', 'kind': 'patch_panel', 'name': 'Patch panel port 3',
|
||||
'cable': 'C07'}
|
||||
|
||||
def test_a_named_stub_keeps_its_name_and_notes_the_panel(self):
|
||||
items = [{'name': 'PP1', 'device': '', 'kind': 'patch_panel'}]
|
||||
cables = [{'id': 2, 'label': 'C02', 'a_device': '24RJ45-POE', 'a_port': '1', 'b_device': 'PP1',
|
||||
'b_port': '2', 'status': 'installed'}]
|
||||
g = build(items=items, cables=cables)
|
||||
stub = node(g, 'stub:24RJ45-POE:1')
|
||||
assert stub['name'] == 'Micro 2 Eth2' and not stub.get('named_by_via')
|
||||
assert stub['via']['name'] == 'Patch panel port 2'
|
||||
|
||||
def test_a_cable_to_a_live_device_is_not_a_via(self):
|
||||
cables = [{'id': 3, 'label': 'C03', 'a_device': 'Dream Machine Pro', 'a_port': '8',
|
||||
'b_device': '8SFP-AGG', 'b_port': '1', 'status': 'installed'}]
|
||||
assert 'via' not in node(build(cables=cables), 'stub:Dream Machine Pro:8')
|
||||
|
||||
|
||||
class TestEmpty:
|
||||
def test_no_data_yet(self):
|
||||
g = topology.build_graph({}, {}, None, [], [], [], None)
|
||||
assert [n['id'] for n in g['nodes']] == [topology.INTERNET]
|
||||
assert g['links'] == [] and g['warnings']
|
||||
|
||||
|
||||
class TestPower:
|
||||
OUTLETS = [
|
||||
{'index': 1, 'name': 'AT&T Modem', 'on': True, 'power_w': 9.0},
|
||||
{'index': 6, 'name': 'Dream Machine Pro', 'on': True, 'power_w': 20.6},
|
||||
{'index': 7, 'name': 'Outlet 7', 'on': True, 'power_w': 48.0},
|
||||
{'index': 14, 'name': 'host-a', 'on': False, 'power_w': 0.0},
|
||||
{'index': 16, 'name': '02:00:5e:00:0a:01', 'on': True, 'power_w': 131.7},
|
||||
{'index': 17, 'name': 'USB Outlet 1', 'on': True, 'power_w': None},
|
||||
]
|
||||
|
||||
def _graph(self, feeds=(), outlets=None):
|
||||
snapshot, link_stats, modem = network()
|
||||
link_stats['unifi_devices']['RPDU']['outlets'] = outlets or self.OUTLETS
|
||||
link_stats['host_macs'] = {'02:00:5e:00:0a:01': ['host-c', 'nic0']}
|
||||
return topology.build_graph(snapshot, link_stats, modem, [], [], [], None, list(feeds))
|
||||
|
||||
def _outlets(self, g, source='RPDU'):
|
||||
return {o['index']: o for o in next(s for s in g['power'] if s['node'] == source)['outlets']}
|
||||
|
||||
def test_matched_by_name_alias_and_mac(self):
|
||||
out = self._outlets(self._graph())
|
||||
assert (out[1]['target'], out[1]['match']) == ('att-modem', 'name')
|
||||
assert (out[6]['target'], out[6]['match']) == ('Dream Machine Pro', 'name')
|
||||
assert (out[14]['target'], out[14]['on']) == ('host-a', False)
|
||||
assert (out[16]['target'], out[16]['match']) == ('host-c', 'mac')
|
||||
|
||||
def test_generic_names_feed_nothing(self):
|
||||
out = self._outlets(self._graph())
|
||||
assert (out[7]['target'], out[7]['match']) == (None, 'none')
|
||||
assert out[17]['target'] is None
|
||||
|
||||
def test_saved_assignment_wins_and_empty_means_nothing(self):
|
||||
feeds = [{'source': 'RPDU', 'outlet': 7, 'target': 'host-b'},
|
||||
{'source': 'RPDU', 'outlet': 6, 'target': ''}]
|
||||
out = self._outlets(self._graph(feeds))
|
||||
assert (out[7]['target'], out[7]['match']) == ('host-b', 'saved')
|
||||
assert (out[6]['target'], out[6]['match']) == (None, 'cleared')
|
||||
|
||||
def test_devices_know_what_feeds_them(self):
|
||||
g = self._graph()
|
||||
assert node(g, 'host-c')['power_in'] == [{'source': 'RPDU', 'outlet': 16, 'on': True, 'power_w': 131.7,
|
||||
'stale': False}]
|
||||
assert node(g, 'host-b')['power_in'] == []
|
||||
|
||||
def test_frozen_readings_are_passed_on_as_stale(self):
|
||||
snapshot, link_stats, modem = network()
|
||||
link_stats['unifi_devices']['RPDU']['outlets'] = [
|
||||
dict(o, stale=True) if o.get('power_w') is not None else o for o in self.OUTLETS]
|
||||
link_stats['unifi_devices']['RPDU']['outlets_stale_since'] = '2026-11-14 22:48:00 UTC'
|
||||
link_stats['host_macs'] = {'02:00:5e:00:0a:01': ['host-c', 'nic0']}
|
||||
g = topology.build_graph(snapshot, link_stats, modem, [], [], [], None, [])
|
||||
src = next(s for s in g['power'] if s['node'] == 'RPDU')
|
||||
assert src['stale_since'] == '2026-11-14 22:48:00 UTC'
|
||||
assert src['outlets'][[o['index'] for o in src['outlets']].index(16)]['stale'] is True
|
||||
assert node(g, 'host-c')['power_in'][0]['stale'] is True
|
||||
assert next(s for s in g['power'] if s['node'] == 'UPS 2U Pro')['stale_since'] is None
|
||||
|
||||
def test_a_power_device_does_not_feed_itself(self):
|
||||
out = self._outlets(self._graph(outlets=[{'index': 1, 'name': 'RPDU spare', 'on': True}]))
|
||||
assert out[1]['target'] is None
|
||||
|
||||
def test_every_power_device_is_listed(self):
|
||||
assert [s['node'] for s in self._graph()['power']] == ['RPDU', 'UPS 2U Pro', 'USP Strip']
|
||||
|
||||
|
||||
class TestPortNameReport:
|
||||
def _report(self, poe_port_11='Port 11', pbs_up=True, extra=(), known=None):
|
||||
snapshot, link_stats, modem = network(poe_port_11, pbs_up)
|
||||
link_stats['unifi_switches']['24RJ45-POE']['ports'].update(dict(extra))
|
||||
return topology.port_name_report(snapshot, link_stats, modem, known)
|
||||
|
||||
def _row(self, rows, sw, idx):
|
||||
return next((r for r in rows if r['switch'] == sw and r['port_idx'] == idx), None)
|
||||
|
||||
def test_named_after_the_wrong_device(self):
|
||||
rows = self._report(poe_port_11='Host-A Management')
|
||||
r = self._row(rows, '24RJ45-POE', 11)
|
||||
assert r['kind'] == 'wrong' and r['suggestion'] == 'AP'
|
||||
assert r['detail'] == ('Named after host-a, but AP is plugged in; '
|
||||
'host-a is on 8SFP-AGG port 1, Dream Machine Pro port 1')
|
||||
assert rows[0] is r # the most urgent kind comes first
|
||||
|
||||
def test_named_after_a_device_that_moved(self):
|
||||
rows = self._report(extra=[port(20, 'host-c', up=False)])
|
||||
r = self._row(rows, '24RJ45-POE', 20)
|
||||
assert r['kind'] == 'moved' and r['suggestion'] == 'Port 20'
|
||||
assert r['detail'] == 'Named after host-c, which is now on 8SFP-AGG port 8'
|
||||
|
||||
def test_named_but_empty_says_who_was_last_seen(self):
|
||||
known = {'pbs': {'uplinks': [{'switch': '24RJ45-POE', 'port_idx': 7}], 'seen': '2026-11-01 10:00:00 UTC'}}
|
||||
rows = self._report(extra=[port(7, 'Guest Bedroom', up=False)], known=known)
|
||||
r = self._row(rows, '24RJ45-POE', 7)
|
||||
assert r['kind'] == 'empty' and r['suggestion'] == ''
|
||||
assert r['detail'] == ('Nothing plugged in; last seen here: pbs (2026-11-01 10:00:00 UTC), '
|
||||
'now on 24RJ45-POE port 15')
|
||||
|
||||
def test_unnamed_ports_get_a_suggestion(self):
|
||||
rows = self._report()
|
||||
# A server with two cables gets its NIC in the name; a switch-to-switch port is a downlink
|
||||
assert self._row(rows, '24RJ45-POE', 4)['suggestion'] == 'host-b enp2s0'
|
||||
assert self._row(rows, '24RJ45-POE', 19)['suggestion'] == 'RPDU'
|
||||
assert self._row(rows, '8SFP-AGG', 7)['suggestion'] == 'Uplink'
|
||||
assert self._row(rows, '8SFP-AGG', 8)['suggestion'] == 'host-c'
|
||||
assert {r['kind'] for r in rows} == {'unnamed'}
|
||||
|
||||
def test_good_names_and_unknown_devices_are_left_alone(self):
|
||||
rows = self._report()
|
||||
for sw, idx in [('24RJ45-POE', 15), # "PBS" with pbs plugged in
|
||||
('24RJ45-POE', 3), # "Living Room Downlink" to the Flex
|
||||
('8SFP-AGG', 5), # "Downlink to 24RJ45-POE"
|
||||
('24RJ45-POE', 1), # a custom name over an unknown device
|
||||
('24RJ45-POE', 8), # an IP-only target
|
||||
('24RJ45-POE', 12), # "Port 12", nothing plugged in
|
||||
('RPDU', 1)]: # a PDU's management port
|
||||
assert self._row(rows, sw, idx) is None, (sw, idx)
|
||||
|
||||
def test_a_port_named_after_a_device_that_is_off_is_right(self):
|
||||
rows = self._report(pbs_up=False)
|
||||
for sw, idx in [('24RJ45-POE', 15)]: # "PBS" while pbs is down
|
||||
assert self._row(rows, sw, idx) is None, (sw, idx)
|
||||
|
||||
def test_no_data(self):
|
||||
assert topology.port_name_report({}, {}, None) == []
|
||||
@@ -0,0 +1,171 @@
|
||||
"""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 "compute-storage-02": 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)
|
||||
|
||||
|
||||
def incident_comment(name: str, summary: str, checks: Sequence[str], when: str) -> str:
|
||||
"""A further report that belongs to the incident this ticket is already about."""
|
||||
lines = [f'**Also seen: {name}** ({when})', '', summary.strip()]
|
||||
if checks:
|
||||
lines += ['', '**What to check**'] + [f'{n}. {check}' for n, check in enumerate(checks, 1)]
|
||||
lines += ['', '_Gandalf added this here instead of opening another ticket, since it is part of '
|
||||
'the same incident._']
|
||||
return '\n'.join(lines)
|
||||
|
||||
|
||||
def update_comment(label: str, when: str, lookback_min: int, hold_min: int) -> str:
|
||||
"""Note on a ticket that a UniFi update finished around the time it was opened."""
|
||||
return '\n'.join([
|
||||
f'**UniFi update:** {label} finished at {when}.', '',
|
||||
f'This ticket was opened within {lookback_min} minutes of that update, which UniFi logs once '
|
||||
f'it is done. Updating the Network app or the gateway firmware can drop the WAN, and Smart '
|
||||
f'Power may then power-cycle the modem, so the update is the likely cause.', '',
|
||||
f'_Gandalf holds new modem and WAN tickets for {hold_min} minutes after an update; anything '
|
||||
f'still wrong after that gets its own ticket._',
|
||||
])
|
||||
@@ -0,0 +1,598 @@
|
||||
"""The live network topology: every device and every physical cable between them.
|
||||
|
||||
Pure functions with no I/O. app.py passes in the monitor's cached state and the
|
||||
cutsheet, and the /topology page draws what build_graph returns.
|
||||
|
||||
The graph comes from the switches' point of view: each UniFi port with a neighbour
|
||||
is one end of a cable. The same switch-to-switch cable is seen from both ends, so
|
||||
those are merged into one link.
|
||||
"""
|
||||
import re
|
||||
from collections import deque
|
||||
from typing import Dict, List, Optional, Tuple
|
||||
|
||||
import devices
|
||||
|
||||
INTERNET = 'internet'
|
||||
|
||||
# How UniFi devices are drawn and grouped. Power gear goes in its own rail.
|
||||
_POWER_MODELS = {'USPPDUP': 'pdu', 'USPDA2B': 'ups', 'UP6': 'strip'}
|
||||
POWER_KINDS = ('pdu', 'ups', 'strip')
|
||||
|
||||
_SEVERITY_RANK = {'critical': 3, 'warning': 2, 'info': 1}
|
||||
_PORT_REF_RE = re.compile(r'(?:^|\s)port\s*(\d+)$', re.IGNORECASE)
|
||||
_TOKEN_RE = re.compile(r'[a-z0-9]+')
|
||||
|
||||
|
||||
def _norm(name: str) -> str:
|
||||
"""A name with case, spaces, dashes and underscores ignored: "Storage-01" == "storage_01"."""
|
||||
return ''.join(_TOKEN_RE.findall((name or '').lower()))
|
||||
|
||||
|
||||
def _node_kind(entry: dict) -> str:
|
||||
if entry['kind'] == 'pdu':
|
||||
return _POWER_MODELS.get(entry.get('model', ''), 'pdu')
|
||||
return entry['kind']
|
||||
|
||||
|
||||
def _medium(port: dict) -> str:
|
||||
"""dac, fibre, sfp (a module that doesn't say which) or copper."""
|
||||
sfp = port.get('sfp') or {}
|
||||
if sfp.get('found') or sfp.get('part'):
|
||||
kind = sfp.get('kind') or ''
|
||||
if kind == 'dac':
|
||||
return 'dac'
|
||||
if kind == 'optic':
|
||||
return 'fibre'
|
||||
return 'sfp'
|
||||
if str(port.get('media') or '').upper().startswith('SFP'):
|
||||
return 'sfp' if port.get('up') else 'copper'
|
||||
return 'copper'
|
||||
|
||||
|
||||
def _rate(value) -> float:
|
||||
try:
|
||||
return max(float(value or 0), 0.0)
|
||||
except (TypeError, ValueError):
|
||||
return 0.0
|
||||
|
||||
|
||||
def _utilisation(a_to_b: float, b_to_a: float, speed_mbps) -> Optional[float]:
|
||||
try:
|
||||
speed = float(speed_mbps or 0)
|
||||
except (TypeError, ValueError):
|
||||
speed = 0.0
|
||||
if speed <= 0:
|
||||
return None
|
||||
return round(min(max(a_to_b, b_to_a) * 8 / (speed * 1e6), 1.0), 4)
|
||||
|
||||
|
||||
def _port_stats(port: dict) -> dict:
|
||||
sfp = port.get('sfp') or {}
|
||||
return {
|
||||
'speed_mbps': port.get('speed_mbps') or 0,
|
||||
'up': bool(port.get('up')),
|
||||
'medium': _medium(port),
|
||||
'sfp_part': sfp.get('part') or '',
|
||||
'sfp_vendor': sfp.get('vendor') or '',
|
||||
'sfp_serial': sfp.get('serial') or '',
|
||||
'errors': round(_rate(port.get('rx_errs_rate')) + _rate(port.get('tx_errs_rate')), 3),
|
||||
'drops': round(_rate(port.get('rx_drops_rate')) + _rate(port.get('tx_drops_rate')), 3),
|
||||
}
|
||||
|
||||
|
||||
def _end(node: str, port_name: str = '', port_idx=None, iface: str = '') -> dict:
|
||||
return {'node': node, 'port_idx': port_idx, 'port_name': port_name, 'iface': iface}
|
||||
|
||||
|
||||
def _far_port(switches: dict, here: str, port: dict, neighbour: str) -> Optional[int]:
|
||||
"""Which port on a neighbouring switch the cable from `port` lands on, if it can be told."""
|
||||
peer = (port.get('sfp') or {}).get('cable_peer') or {}
|
||||
if peer.get('switch') == neighbour and peer.get('port_idx') is not None:
|
||||
return peer['port_idx']
|
||||
far = switches.get(neighbour)
|
||||
if not far:
|
||||
return None
|
||||
ports = [p for p in (far.get('ports') or {}).values() if p.get('port_idx') is not None]
|
||||
# LLDP's port ID names the neighbour's own port ("Port 3", "local Port 7")
|
||||
m = _PORT_REF_RE.search(str((port.get('lldp') or {}).get('port_id') or '').strip())
|
||||
if m and any(p['port_idx'] == int(m.group(1)) for p in ports):
|
||||
return int(m.group(1))
|
||||
back = [p['port_idx'] for p in ports if (p.get('lldp') or {}).get('system_name') == here]
|
||||
if len(back) == 1:
|
||||
return back[0]
|
||||
# Gear that sends no LLDP of its own (a PDU): its single uplink
|
||||
uplinks = [p['port_idx'] for p in ports if p.get('is_uplink')]
|
||||
return uplinks[0] if len(uplinks) == 1 else None
|
||||
|
||||
|
||||
def _is_generic_port_name(name: str) -> bool:
|
||||
return bool(re.fullmatch(r'(port|sfp\+?|uplink|downlink)\s*\d*', (name or '').strip(), re.IGNORECASE))
|
||||
|
||||
|
||||
def name_mismatch(port_name: str, neighbour: str, own: str, known: Dict[str, str]) -> Optional[dict]:
|
||||
"""A port named after a different device than the one plugged into it.
|
||||
|
||||
known: {normalised name: display name} of every device. Runs of up to four words of
|
||||
the port name are compared with them, so "Storage-01 Management" names storage-01 and
|
||||
"Downlink to 24RJ45-POE" names 24RJ45-POE. Ports named only "Port 4" never match.
|
||||
"""
|
||||
if not port_name or _is_generic_port_name(port_name):
|
||||
return None
|
||||
named = _named_device(port_name, known, {_norm(neighbour), _norm(own)})
|
||||
return {'named': named, 'actual': neighbour} if named else None
|
||||
|
||||
|
||||
def _named_device(text: str, known: Dict[str, str], skip=()) -> Optional[str]:
|
||||
"""The device a free-text name refers to: the longest run of up to four of its words that
|
||||
is a device name (ignoring case, spaces, dashes and underscores), or None."""
|
||||
words = _TOKEN_RE.findall((text or '').lower())
|
||||
for size in range(min(4, len(words)), 0, -1):
|
||||
for i in range(len(words) - size + 1):
|
||||
run = ''.join(words[i:i + size])
|
||||
if run in known and run not in skip:
|
||||
return known[run]
|
||||
return None
|
||||
|
||||
|
||||
# What each port-name finding means, most urgent first
|
||||
PORT_NAME_KINDS = ('wrong', 'moved', 'empty', 'unnamed')
|
||||
|
||||
|
||||
def _port_name_suggestion(neighbour: str, kind: str, port: dict, links: int) -> str:
|
||||
if kind in ('router', 'switch'):
|
||||
return 'Uplink' if port.get('is_uplink') else f'Downlink to {neighbour}'
|
||||
iface = str((port.get('lldp') or {}).get('port_id') or '')
|
||||
# A server with two cables: say which NIC, so the two ports read differently
|
||||
if kind == 'host' and links > 1 and iface and not _MAC_IN_TEXT.fullmatch(iface):
|
||||
return f'{neighbour} {iface}'
|
||||
return neighbour
|
||||
|
||||
|
||||
def port_name_report(snapshot: dict, link_stats: dict, modem: Optional[dict],
|
||||
known_uplinks: Optional[dict] = None) -> List[dict]:
|
||||
"""UniFi port names that no longer fit what is plugged in, as a checklist to fix in UniFi.
|
||||
|
||||
Each row is {switch, port_idx, port_name, kind, neighbour, suggestion, detail}, kind one of:
|
||||
wrong: named after one device, with a different known device plugged in
|
||||
moved: named after a device that is now linked on another port, with nothing known here
|
||||
empty: a custom name on a port with nothing plugged in (with who was last seen there)
|
||||
unnamed: still "Port N" / "SFP+ N" with a known device plugged in
|
||||
Gandalf only reports these; it never renames anything in UniFi.
|
||||
"""
|
||||
snapshot = snapshot or {}
|
||||
link_stats = link_stats or {}
|
||||
switches = link_stats.get('unifi_switches') or {}
|
||||
configured = set(snapshot.get('hosts') or {})
|
||||
kinds = {e['name']: e['kind'] for e in devices.build_index(snapshot, link_stats, modem)
|
||||
if e['kind'] != 'host' or e['name'] in configured}
|
||||
known = {_norm(n): n for n in kinds}
|
||||
|
||||
# Where each known device is linked right now, and who was last seen on each port
|
||||
live_at: Dict[str, List[str]] = {}
|
||||
for sw_name, sw in sorted(switches.items()):
|
||||
for p in (sw.get('ports') or {}).values():
|
||||
nb = (p.get('lldp') or {}).get('system_name') or ''
|
||||
if p.get('up') and nb in kinds and p.get('port_idx') is not None:
|
||||
live_at.setdefault(nb, []).append(f'{sw_name} port {p["port_idx"]}')
|
||||
last_seen: Dict[Tuple[str, int], Tuple[str, str]] = {}
|
||||
for name, entry in (known_uplinks or {}).items():
|
||||
for up in (entry or {}).get('uplinks') or []:
|
||||
if up.get('switch') and up.get('port_idx') is not None:
|
||||
last_seen[(up['switch'], up['port_idx'])] = (name, (entry or {}).get('seen') or '')
|
||||
|
||||
rows: List[dict] = []
|
||||
for sw_name in sorted(switches):
|
||||
if kinds.get(sw_name) in POWER_KINDS or _POWER_MODELS.get((switches[sw_name] or {}).get('model', '')):
|
||||
continue # a PDU's one management port
|
||||
for pname, port in (switches[sw_name].get('ports') or {}).items():
|
||||
idx = port.get('port_idx')
|
||||
if idx is None:
|
||||
continue
|
||||
nb = (port.get('lldp') or {}).get('system_name') or ''
|
||||
nb = nb if nb in kinds and nb != sw_name else ''
|
||||
generic = _is_generic_port_name(pname)
|
||||
row = {'switch': sw_name, 'port_idx': idx, 'port_name': pname, 'neighbour': nb,
|
||||
'suggestion': '', 'detail': ''}
|
||||
named = None if generic else _named_device(pname, known, {_norm(sw_name)})
|
||||
if nb and port.get('up'):
|
||||
suggestion = _port_name_suggestion(nb, kinds[nb], port, len(live_at.get(nb, [])))
|
||||
if named and named != nb and _norm(named) != _norm(nb):
|
||||
elsewhere = [w for w in live_at.get(named, []) if w != f'{sw_name} port {idx}']
|
||||
row.update(kind='wrong', suggestion=suggestion,
|
||||
detail=f'Named after {named}, but {nb} is plugged in'
|
||||
+ (f'; {named} is on {", ".join(elsewhere)}' if elsewhere else ''))
|
||||
elif generic and not pname.lower().startswith(('uplink', 'downlink')):
|
||||
row.update(kind='unnamed', suggestion=suggestion,
|
||||
detail=f'{nb} is plugged in')
|
||||
else:
|
||||
continue
|
||||
elif named and named in live_at:
|
||||
row.update(kind='moved', suggestion=f'Port {idx}' if not port.get('up') else '',
|
||||
detail=f'Named after {named}, which is now on {", ".join(live_at[named])}')
|
||||
elif named:
|
||||
continue # named after a known device that is just not linked now: the name is right
|
||||
elif not generic and not port.get('up') and not port.get('lldp'):
|
||||
seen = last_seen.get((sw_name, idx))
|
||||
detail = 'Nothing plugged in'
|
||||
if seen:
|
||||
detail += f'; last seen here: {seen[0]}' + (f' ({seen[1]})' if seen[1] else '')
|
||||
if seen[0] in live_at:
|
||||
detail += f', now on {", ".join(live_at[seen[0]])}'
|
||||
row.update(kind='empty', detail=detail)
|
||||
else:
|
||||
continue
|
||||
rows.append(row)
|
||||
order = {k: i for i, k in enumerate(PORT_NAME_KINDS)}
|
||||
rows.sort(key=lambda r: (order[r['kind']], r['switch'].lower(), r['port_idx']))
|
||||
return rows
|
||||
|
||||
|
||||
_MAC_IN_TEXT = re.compile(r'\b([0-9a-f]{2}(?:[:-][0-9a-f]{2}){5})\b', re.IGNORECASE)
|
||||
|
||||
|
||||
def build_power(nodes: Dict[str, dict], link_stats: dict, feeds: List[dict]) -> List[dict]:
|
||||
"""What every PDU, UPS and power strip outlet feeds.
|
||||
|
||||
In order: an assignment saved on the topology page (target '' means nothing), then the
|
||||
outlet's name if it names a device ("storage-01", "Dream Machine Pro", or "AT&T Modem" for
|
||||
the modem), then a MAC in its name that belongs to a host NIC or a UniFi device.
|
||||
Returns [{node, power_w, stale_since, outlets: [{index, name, on, power_w, stale,
|
||||
auto_power_cycle, target, match: saved|cleared|name|mac|none}]}]. stale_since is set when
|
||||
the monitor saw the unit's outlet readings stop changing (UniFi serving a frozen snapshot).
|
||||
"""
|
||||
known = {_norm(n['name']): n['name'] for n in nodes.values() if n['kind'] not in ('stub', 'internet')}
|
||||
modem = next((n['name'] for n in nodes.values() if n['kind'] == 'modem'), None)
|
||||
macs = {str(mac).lower(): owner[0] for mac, owner in (link_stats.get('host_macs') or {}).items() if owner}
|
||||
for name, info in (link_stats.get('unifi_devices') or {}).items():
|
||||
if info.get('mac'):
|
||||
macs.setdefault(info['mac'].lower(), name)
|
||||
saved = {}
|
||||
for f in feeds or []:
|
||||
try:
|
||||
saved[(f['source'], int(f['outlet']))] = f.get('target') or ''
|
||||
except (KeyError, TypeError, ValueError):
|
||||
continue
|
||||
|
||||
sources = []
|
||||
for node in sorted((n for n in nodes.values() if n.get('power')), key=lambda n: n['name'].lower()):
|
||||
rows = []
|
||||
for o in node.get('outlets') or []:
|
||||
idx = o.get('index')
|
||||
text = str(o.get('name') or '')
|
||||
target, how = None, 'none'
|
||||
if (node['name'], idx) in saved:
|
||||
target = saved[(node['name'], idx)] or None
|
||||
how = 'saved' if target else 'cleared'
|
||||
else:
|
||||
target = _named_device(text, known, {_norm(node['name'])})
|
||||
if not target and modem and 'modem' in _TOKEN_RE.findall(text.lower()):
|
||||
target = modem
|
||||
if target:
|
||||
how = 'name'
|
||||
else:
|
||||
m = _MAC_IN_TEXT.search(text)
|
||||
target = macs.get(m.group(1).lower().replace('-', ':')) if m else None
|
||||
how = 'mac' if target else 'none'
|
||||
rows.append({'index': idx, 'name': text, 'on': o.get('on') is not False,
|
||||
'power_w': o.get('power_w'), 'stale': bool(o.get('stale')),
|
||||
'auto_power_cycle': bool(o.get('auto_power_cycle')),
|
||||
'target': target, 'match': how})
|
||||
sources.append({'node': node['name'], 'power_w': node.get('power_w'), 'outlets': rows,
|
||||
'stale_since': node.get('outlets_stale_since')})
|
||||
return sources
|
||||
|
||||
|
||||
def _cable_labels(items: List[dict], cables: List[dict]) -> Dict[Tuple[str, str], dict]:
|
||||
"""{(device, port): cable} for cutsheet cables still in place. A cable can name the
|
||||
device itself or a cutsheet item linked to it. Each entry also says where the cable's
|
||||
other end goes ('far': {device, port, kind}), so a cable into a patch panel shows as one."""
|
||||
by_name = {i['name']: i for i in items or []}
|
||||
device_of = {name: (i.get('device') or name) for name, i in by_name.items()}
|
||||
out: Dict[Tuple[str, str], dict] = {}
|
||||
for c in cables or []:
|
||||
if c.get('status') == 'retired':
|
||||
continue
|
||||
for end, other in (('a', 'b'), ('b', 'a')):
|
||||
dev = c.get(f'{end}_device') or ''
|
||||
if not dev:
|
||||
continue
|
||||
far_dev = c.get(f'{other}_device') or ''
|
||||
ref = {'id': c.get('id'), 'label': c.get('label') or '', 'type': c.get('cable_type') or '',
|
||||
'color': c.get('color') or '',
|
||||
'far': {'device': device_of.get(far_dev, far_dev), 'port': str(c.get(f'{other}_port') or ''),
|
||||
'kind': (by_name.get(far_dev) or {}).get('kind') or ''} if far_dev else None}
|
||||
for name in {dev, device_of.get(dev, dev)}:
|
||||
out[(name, str(c.get(f'{end}_port') or ''))] = ref
|
||||
return out
|
||||
|
||||
|
||||
def _via_name(far: dict) -> str:
|
||||
"""How to name the far end of a cable that leads to cutsheet gear, not a live device."""
|
||||
where = {'patch_panel': 'Patch panel', 'wall_jack': 'Wall jack'}.get(far['kind'], far['device'])
|
||||
return f'{where} port {far["port"]}' if far['port'] else where
|
||||
|
||||
|
||||
def _alerts_by_target(events: List[dict]) -> Dict[str, List[dict]]:
|
||||
out: Dict[str, List[dict]] = {}
|
||||
for ev in events or []:
|
||||
if ev.get('is_suppressed'):
|
||||
continue
|
||||
out.setdefault(ev.get('target_name') or '', []).append({
|
||||
'id': ev.get('id'), 'severity': ev.get('severity') or 'info',
|
||||
'type': ev.get('event_type') or '', 'detail': ev.get('target_detail') or '',
|
||||
'description': ev.get('description') or '',
|
||||
})
|
||||
return out
|
||||
|
||||
|
||||
def _worst(alerts: List[dict]) -> str:
|
||||
return max((a['severity'] for a in alerts), key=lambda s: _SEVERITY_RANK.get(s, 0), default='')
|
||||
|
||||
|
||||
def build_graph(snapshot: dict, link_stats: dict, modem: Optional[dict], events: List[dict],
|
||||
cutsheet_items: List[dict], cutsheet_cables: List[dict],
|
||||
known_uplinks: Optional[dict] = None, power_feeds: Optional[List[dict]] = None) -> dict:
|
||||
"""Every device and cable, as {nodes, links, power, warnings, updated}.
|
||||
|
||||
snapshot, link_stats, modem: the monitor's saved state.
|
||||
events: active events, with is_suppressed set (suppressed ones are left out).
|
||||
known_uplinks: the monitor's record of where each device was last plugged in,
|
||||
drawn as "last seen" links for a device with no live link.
|
||||
power_feeds: outlet assignments saved on the topology page (see build_power).
|
||||
"""
|
||||
snapshot = snapshot or {}
|
||||
link_stats = link_stats or {}
|
||||
switches = link_stats.get('unifi_switches') or {}
|
||||
unifi_info = link_stats.get('unifi_devices') or {}
|
||||
alerts = _alerts_by_target(events)
|
||||
labels = _cable_labels(cutsheet_items, cutsheet_cables)
|
||||
chassis = {}
|
||||
for item in cutsheet_items or []:
|
||||
chassis.setdefault(item.get('device') or item['name'], item.get('chassis') or '')
|
||||
warnings: List[str] = []
|
||||
|
||||
# ── Nodes ────────────────────────────────────────────────────────────
|
||||
nodes: Dict[str, dict] = {}
|
||||
configured = set(snapshot.get('hosts') or {})
|
||||
for entry in devices.build_index(snapshot, link_stats, modem):
|
||||
name = entry['name']
|
||||
if entry['kind'] == 'host' and name not in configured:
|
||||
continue # IP-only Prometheus targets: shown only as a stub where a port sees them
|
||||
kind = _node_kind(entry)
|
||||
node = {
|
||||
'id': name, 'name': name, 'kind': kind, 'status': entry['status'], 'model': entry.get('model', ''),
|
||||
'ip': entry.get('ip', ''), 'url': f'/device/{name}', 'power': kind in POWER_KINDS,
|
||||
}
|
||||
if kind == 'host':
|
||||
node['chassis'] = chassis.get(name, '')
|
||||
node['interfaces'] = devices.physical_interfaces(name, snapshot)
|
||||
for nic in node['interfaces']:
|
||||
nic_alerts = [a for a in alerts.get(name, []) if a['detail'] == nic['name']]
|
||||
nic['alert'] = _worst(nic_alerts)
|
||||
elif name in switches or kind in ('router', 'switch'):
|
||||
node['ports'] = {
|
||||
str(p['port_idx']): {'name': pname, 'up': bool(p.get('up')), 'speed_mbps': p.get('speed_mbps') or 0,
|
||||
'is_uplink': bool(p.get('is_uplink')), 'media': p.get('media') or '',
|
||||
'poe_power': p.get('poe_power'), 'sfp': p.get('sfp') or None,
|
||||
'tx_bytes_rate': _rate(p.get('tx_bytes_rate')),
|
||||
'rx_bytes_rate': _rate(p.get('rx_bytes_rate')),
|
||||
'neighbour': (p.get('lldp') or {}).get('system_name') or ''}
|
||||
for pname, p in ((switches.get(name) or {}).get('ports') or {}).items()
|
||||
if p.get('port_idx') is not None
|
||||
}
|
||||
if kind in POWER_KINDS:
|
||||
info = unifi_info.get(name) or {}
|
||||
node['power_w'] = info.get('power_w')
|
||||
node['outlets'] = info.get('outlets') or []
|
||||
node['outlets_stale_since'] = info.get('outlets_stale_since')
|
||||
node_alerts = alerts.get(name, [])
|
||||
node['alerts'] = node_alerts[:10]
|
||||
node['alert_count'] = len(node_alerts)
|
||||
node['severity'] = _worst(node_alerts)
|
||||
nodes[name] = node
|
||||
|
||||
router = next((n for n in nodes.values() if n['kind'] == 'router'), None)
|
||||
modem_name = (modem or {}).get('name') if (modem or {}).get('name') in nodes else None
|
||||
wan = ((unifi_info.get(router['name']) or {}).get('wan') or {}) if router else {}
|
||||
wan_up = any(w.get('up') for w in wan.values()) if wan else None
|
||||
if modem_name:
|
||||
wan_up = (modem or {}).get('broadband_state', '').lower() == 'up' if wan_up is None else wan_up
|
||||
nodes[INTERNET] = {
|
||||
'id': INTERNET, 'name': 'Internet', 'kind': INTERNET, 'model': '', 'ip': '', 'url': '',
|
||||
'status': 'unknown' if wan_up is None else ('up' if wan_up else 'down'),
|
||||
'alerts': alerts.get('WAN', [])[:10], 'alert_count': len(alerts.get('WAN', [])),
|
||||
'severity': _worst(alerts.get('WAN', [])), 'power': False,
|
||||
}
|
||||
known_names = {_norm(n['name']): n['name'] for n in nodes.values() if n['id'] != INTERNET}
|
||||
|
||||
# ── Links ────────────────────────────────────────────────────────────
|
||||
links: List[dict] = []
|
||||
claimed: Dict[Tuple[str, int], dict] = {}
|
||||
|
||||
def add_link(a: dict, b: dict, port: dict, **extra) -> dict:
|
||||
link = {'id': '', 'a': a, 'b': b, 'ghost': False, 'name_mismatch': None,
|
||||
'cable': labels.get((a['node'], str(a['port_idx'] if a['port_idx'] is not None else a['iface'])))
|
||||
or labels.get((b['node'], str(b['port_idx'] if b['port_idx'] is not None else b['iface']))),
|
||||
**_port_stats(port),
|
||||
'_tx': _rate(port.get('tx_bytes_rate')), '_rx': _rate(port.get('rx_bytes_rate'))}
|
||||
link.update(extra)
|
||||
links.append(link)
|
||||
for end in (a, b):
|
||||
if end['port_idx'] is not None and end['node'] in switches:
|
||||
claimed[(end['node'], end['port_idx'])] = link
|
||||
return link
|
||||
|
||||
def ordered_ports(sw: dict):
|
||||
return sorted(((pn, p) for pn, p in (sw.get('ports') or {}).items() if p.get('port_idx') is not None),
|
||||
key=lambda kv: kv[1]['port_idx'])
|
||||
|
||||
# The router's internet port goes to the modem, then the modem to the internet
|
||||
wan_port = None
|
||||
if router and router['name'] in switches:
|
||||
wan_port = next(((pn, p) for pn, p in ordered_ports(switches[router['name']]) if p.get('is_uplink')), None)
|
||||
upstream = modem_name or INTERNET
|
||||
if wan_port:
|
||||
pn, p = wan_port
|
||||
add_link(_end(router['name'], pn, p['port_idx']), _end(upstream, 'WAN' if modem_name else ''), p, wan=True)
|
||||
elif router:
|
||||
warnings.append(f'No internet port found on {router["name"]}')
|
||||
if modem_name:
|
||||
m = modem or {}
|
||||
rates = m.get('rates') or {}
|
||||
up = str(m.get('broadband_state') or '').lower() == 'up'
|
||||
links.append({
|
||||
'id': '', 'a': _end(INTERNET), 'b': _end(modem_name, str(m.get('source') or 'WAN').title()),
|
||||
'ghost': False, 'name_mismatch': None, 'cable': None, 'wan': True,
|
||||
'speed_mbps': m.get('line_speed_mbps') or 0, 'up': up,
|
||||
'medium': 'fibre' if str(m.get('source') or '').upper() == 'FIBER' else 'copper',
|
||||
'sfp_part': m.get('optics_part_no') or '', 'sfp_vendor': '', 'sfp_serial': '',
|
||||
'errors': round(_rate(rates.get('rx_errors')) + _rate(rates.get('tx_errors')), 3),
|
||||
'drops': round(_rate(rates.get('rx_drops')) + _rate(rates.get('tx_drops')), 3),
|
||||
# Seen from the modem's broadband side: rx comes down from the internet
|
||||
'_tx': _rate(rates.get('rx_bytes')), '_rx': _rate(rates.get('tx_bytes')),
|
||||
})
|
||||
elif not router:
|
||||
warnings.append('No UniFi gateway reported yet, so the internet edge is not drawn')
|
||||
|
||||
# Device-to-device and device-to-host cables, from every switch port with a neighbour
|
||||
for sw_name in sorted(switches):
|
||||
for pname, port in ordered_ports(switches[sw_name]):
|
||||
idx = port['port_idx']
|
||||
if (sw_name, idx) in claimed:
|
||||
continue
|
||||
lldp = port.get('lldp') or {}
|
||||
neighbour = lldp.get('system_name') or ''
|
||||
here = _end(sw_name, pname, idx)
|
||||
if neighbour in nodes and neighbour != sw_name:
|
||||
nb = nodes[neighbour]
|
||||
if nb['kind'] == 'host':
|
||||
far = _end(neighbour, iface=lldp.get('port_id') or '')
|
||||
else:
|
||||
far_idx = _far_port(switches, sw_name, port, neighbour)
|
||||
if far_idx is not None and (neighbour, far_idx) in claimed:
|
||||
continue # the other end already drew this cable
|
||||
far_port = next((pn for pn, p in ((switches.get(neighbour) or {}).get('ports') or {}).items()
|
||||
if p.get('port_idx') == far_idx), '') if far_idx is not None else ''
|
||||
far = _end(neighbour, far_port, far_idx)
|
||||
link = add_link(here, far, port)
|
||||
link['name_mismatch'] = name_mismatch(pname, neighbour, sw_name, known_names)
|
||||
if link['name_mismatch'] is None and far['port_name']:
|
||||
link['name_mismatch'] = name_mismatch(far['port_name'], sw_name, neighbour, known_names)
|
||||
if link['name_mismatch']:
|
||||
link['name_mismatch']['end'] = 'b'
|
||||
elif link['name_mismatch']:
|
||||
link['name_mismatch']['end'] = 'a'
|
||||
continue
|
||||
if port.get('is_uplink') and not neighbour:
|
||||
continue # leads upstream to gear already drawn (a PDU's management port)
|
||||
if not port.get('up') and not lldp:
|
||||
continue
|
||||
# Something is plugged in that Gandalf can't name: a grey stub
|
||||
stub_id = f'stub:{sw_name}:{idx}'
|
||||
mac = lldp.get('chassis_id') or ''
|
||||
label = neighbour or ('' if _is_generic_port_name(pname) else pname) or mac or 'unknown device'
|
||||
nodes[stub_id] = {
|
||||
'id': stub_id, 'name': label, 'kind': 'stub', 'status': 'up' if port.get('up') else 'down',
|
||||
'model': '', 'ip': neighbour if re.fullmatch(r'[\d.]+', neighbour) else '', 'mac': mac,
|
||||
'url': f'/device/{sw_name}#port-{idx}', 'switch': sw_name, 'port_idx': idx, 'port_name': pname,
|
||||
'iface': (lldp.get('port_id') or '') if neighbour else '', 'anonymous': not lldp,
|
||||
'alerts': [], 'alert_count': 0, 'severity': '', 'power': False,
|
||||
}
|
||||
link = add_link(here, _end(stub_id, iface=nodes[stub_id]['iface']), port)
|
||||
# The cutsheet says the cable goes into a patch panel (or other documented gear that
|
||||
# is not on the network): say so, and name a stub that has nothing better after it
|
||||
far = (link['cable'] or {}).get('far')
|
||||
if far and far['device'] not in nodes:
|
||||
nodes[stub_id]['via'] = dict(far, name=_via_name(far), cable=link['cable']['label'])
|
||||
if label == 'unknown device':
|
||||
nodes[stub_id]['name'] = nodes[stub_id]['via']['name']
|
||||
nodes[stub_id]['named_by_via'] = True
|
||||
# A stub labelled by its port name would always "match" it, so compare with what was seen
|
||||
link['name_mismatch'] = name_mismatch(pname, neighbour or mac or 'an unnamed device', sw_name, known_names)
|
||||
if link['name_mismatch']:
|
||||
link['name_mismatch']['end'] = 'a'
|
||||
|
||||
# Gear with no live cable: draw where it was last plugged in
|
||||
linked = {e['node'] for link in links for e in (link['a'], link['b'])}
|
||||
for name, entry in sorted((known_uplinks or {}).items()):
|
||||
node = nodes.get(name)
|
||||
if not node or name in linked or node['kind'] == 'stub':
|
||||
continue
|
||||
for up in entry.get('uplinks') or []:
|
||||
sw, idx = up.get('switch'), up.get('port_idx')
|
||||
if sw not in nodes or idx is None or (sw, idx) in claimed:
|
||||
continue
|
||||
port = next((p for p in ((switches.get(sw) or {}).get('ports') or {}).values()
|
||||
if p.get('port_idx') == idx), {})
|
||||
far = (_end(name, iface=up.get('host_interface') or '') if node['kind'] == 'host'
|
||||
else _end(name, '', None))
|
||||
link = add_link(_end(sw, up.get('port') or '', idx), far, port,
|
||||
ghost=True, seen=entry.get('seen') or '')
|
||||
link['up'] = False
|
||||
|
||||
# ── Depth: hops from the internet over device-to-device cables ───────
|
||||
adjacency: Dict[str, set] = {}
|
||||
for link in links:
|
||||
a, b = link['a']['node'], link['b']['node']
|
||||
adjacency.setdefault(a, set()).add(b)
|
||||
adjacency.setdefault(b, set()).add(a)
|
||||
depth: Dict[str, int] = {INTERNET: 0}
|
||||
queue = deque([INTERNET])
|
||||
while queue:
|
||||
cur = queue.popleft()
|
||||
for nxt in sorted(adjacency.get(cur, ())):
|
||||
if nxt in depth:
|
||||
continue
|
||||
depth[nxt] = depth[cur] + 1
|
||||
# Hosts and stubs are leaves: they never carry the path on to another device
|
||||
if nodes[nxt]['kind'] not in ('host', 'stub'):
|
||||
queue.append(nxt)
|
||||
for node in nodes.values():
|
||||
node['depth'] = depth.get(node['id'])
|
||||
|
||||
# Orient each cable from the internet side (a) to the far side (b), and count traffic that way
|
||||
for i, link in enumerate(links):
|
||||
da = depth.get(link['a']['node'], 1 << 20)
|
||||
db_ = depth.get(link['b']['node'], 1 << 20)
|
||||
# Rates were measured at end a as added: the reporting switch port, or the internet side
|
||||
tx, rx = link.pop('_tx'), link.pop('_rx')
|
||||
if db_ < da:
|
||||
link['a'], link['b'] = link['b'], link['a']
|
||||
if link.get('name_mismatch') and link['name_mismatch'].get('end'):
|
||||
link['name_mismatch']['end'] = 'a' if link['name_mismatch']['end'] == 'b' else 'b'
|
||||
tx, rx = rx, tx
|
||||
link['a_to_b_bps'] = round(tx, 1)
|
||||
link['b_to_a_bps'] = round(rx, 1)
|
||||
link['utilisation'] = _utilisation(tx, rx, link['speed_mbps'])
|
||||
link['id'] = f'l{i}'
|
||||
|
||||
# Which host NIC each cable lands on, so the drawing can light the right socket
|
||||
for link in links:
|
||||
for end in (link['a'], link['b']):
|
||||
node = nodes[end['node']]
|
||||
if node['kind'] == 'host' and end['iface']:
|
||||
for nic in node.get('interfaces', []):
|
||||
if nic['name'] == end['iface']:
|
||||
nic.setdefault('links', []).append(link['id'])
|
||||
|
||||
# Power: what each outlet feeds, and on each device, the outlets feeding it
|
||||
power = build_power({k: v for k, v in nodes.items() if v['kind'] != 'stub'}, link_stats, power_feeds or [])
|
||||
for node in nodes.values():
|
||||
node['power_in'] = []
|
||||
for src in power:
|
||||
for o in src['outlets']:
|
||||
if o['target'] in nodes:
|
||||
nodes[o['target']]['power_in'].append(
|
||||
{'source': src['node'], 'outlet': o['index'], 'on': o['on'], 'power_w': o['power_w'],
|
||||
'stale': o['stale']})
|
||||
|
||||
if not switches:
|
||||
warnings.append('No UniFi switch data yet: the monitor has not reported any ports')
|
||||
return {
|
||||
'nodes': sorted(nodes.values(), key=lambda n: (99 if n['depth'] is None else n['depth'], n['name'].lower())),
|
||||
'links': links,
|
||||
'power': power,
|
||||
'warnings': warnings,
|
||||
'updated': link_stats.get('updated'),
|
||||
}
|
||||